/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_depthwise_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/depthwise_conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using InputBackpropWindow3Stride1 =
    sycldnn::depthwise_conv2d::WindowStrideTest<Pair, 3, 1>;
TYPED_TEST_SUITE(InputBackpropWindow3Stride1, GTestTypePairs);
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29.,  62.,  83.,  75.,  99.,  192.,
                                         237., 198., 207., 372., 417., 330.,
                                         263., 446., 485., 365.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  4.,  7.,  6.,  7.,  23.,
                                         33., 24., 19., 53., 63., 42.,
                                         21., 52., 59., 36.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,  412.,  568.,  528.,  678.,  1347., 1689., 1434.,
      1494., 2715., 3057., 2442., 1968., 3352., 3652., 2760.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   22.,  42.,  39.,  40.,  144.,
                                         216., 164., 124., 360., 432., 296.,
                                         149., 374., 426., 263.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,  4172.,  3944.,  4980.,  10038., 12702., 10884.,
      11316., 20694., 23358., 18756., 15208., 25964., 28316., 21448.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,  140.,  284.,  278.,  260.,  1000., 1544., 1204.,
      884., 2632., 3176., 2212., 1118., 2828., 3228., 2006.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68.,  116.,  164.,  248.,  236.,  332.,  228.,  300.,
      282., 396.,  579.,  768.,  741.,  948.,  642.,  792.,
      666., 828.,  1227., 1488., 1389., 1668., 1122., 1320.,
      916., 1052., 1568., 1784., 1712., 1940., 1300., 1460.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   6.,   16., 14.,  28.,  15.,  24.,  12.,  28.,  52.,
      92.,  84.,  132., 68., 96.,  48.,  76.,  148., 212., 180., 252.,
      128., 168., 65.,  84., 166., 208., 190., 236., 119., 144.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      460.,  828.,  1162.,  1810.,  1714.,  2458.,  1692.,  2252.,
      2046., 2934., 4281.,  5757.,  5541.,  7161.,  4854.,  6030.,
      5022., 6294., 9321.,  11373., 10581., 12777., 8598.,  10158.,
      7068., 8140., 12130., 13834., 13258., 15058., 10092., 11356.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   25.,   34.,  106., 90.,   194.,  105.,  173.,  70.,   190.,  348.,
      652., 588.,  956., 494., 710.,  334.,  550.,  1068., 1564., 1308., 1868.,
      950., 1262., 485., 633., 1250., 1578., 1434., 1794., 905.,  1101.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3352.,  6232.,  8708.,  13796.,  13028.,  18884.,  13016., 17432.,
      15540., 22548., 32862., 44526.,  42798.,  55614.,  37716., 47028.,
      38964., 49044., 72606., 88878.,  82542.,  99966.,  67284., 79668.,
      55512., 64024., 95396., 108932., 104324., 118628., 79512., 89560.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   174.,  220.,  764.,   636.,   1436.,  782.,  1310.,
      460.,  1388., 2520., 4888.,  4376.,  7256.,  3756., 5452.,
      2476., 4172., 8088., 11992., 9944.,  14360., 7308., 9772.,
      3742., 4910., 9692., 12284., 11132., 13980., 7054., 8606.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      188.,  272.,  364.,  464.,  506.,  656.,  818.,  992.,  770.,  944.,
      1130., 1328., 780.,  912.,  1052., 1200., 918.,  1128., 1350., 1584.,
      1965., 2316., 2685., 3072., 2577., 2964., 3369., 3792., 2286., 2568.,
      2862., 3168., 2358., 2664., 2982., 3312., 4413., 4908., 5421., 5952.,
      5025., 5556., 6105., 6672., 4110., 4488., 4878., 5280., 3404., 3664.,
      3932., 4208., 5858., 6272., 6698., 7136., 6410., 6848., 7298., 7760.,
      4892., 5200., 5516., 5840.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   9.,   16.,  10.,  24.,  42.,  64.,  34.,  56.,  82.,
      112., 45.,  60.,  77.,  96.,  22.,  48.,  78.,  112., 140., 208.,
      284., 368., 252., 336., 428., 528., 222., 272., 326., 384., 142.,
      192., 246., 304., 476., 592., 716., 848., 588., 720., 860., 1008.,
      438., 512., 590., 672., 225., 260., 297., 336., 586., 664., 746.,
      832., 674., 760., 850., 944., 429., 476., 525., 576.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1348.,  2004.,  2724.,  3508.,  3766.,  4942.,  6214.,  7582.,
      5830.,  7198.,  8662.,  10222., 5988.,  7028.,  8132.,  9300.,
      6942.,  8598.,  10350., 12198., 15045., 17817., 20733., 23793.,
      19869., 22929., 26133., 29481., 17742., 19974., 22302., 24726.,
      18270., 20694., 23214., 25830., 34341., 38265., 42333., 46545.,
      39165., 43377., 47733., 52233., 32142., 35142., 38238., 41430.,
      26724., 28788., 30916., 33108., 46054., 49342., 52726., 56206.,
      50422., 53902., 57478., 61150., 38532., 40980., 43492., 46068.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    25.,   61.,   113.,  58.,   162.,  298.,  466.,  234.,  402.,
      602.,  834.,  333.,  449.,  581.,  729.,  130.,  330.,  562.,  826.,
      996.,  1524., 2116., 2772., 1860., 2516., 3236., 4020., 1682., 2074.,
      2498., 2954., 1042., 1434., 1858., 2314., 3588., 4500., 5476., 6516.,
      4452., 5492., 6596., 7764., 3362., 3946., 4562., 5210., 1733., 2009.,
      2301., 2609., 4538., 5154., 5802., 6482., 5226., 5906., 6618., 7362.,
      3341., 3713., 4101., 4505.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10168.,  15352.,  21048.,  27256.,  29012.,  38324.,  48404.,  59252.,
      45332.,  56180.,  67796.,  80180.,  46904.,  55160.,  63928.,  73208.,
      53940.,  67092.,  81012.,  95700.,  117678., 139710., 162894., 187230.,
      155982., 180318., 205806., 232446., 139764., 157524., 176052., 195348.,
      143796., 163092., 183156., 203988., 270894., 302142., 334542., 368094.,
      309198., 342750., 377454., 413310., 254196., 278100., 302772., 328212.,
      211768., 228216., 245176., 262648., 365204., 391412., 418388., 446132.,
      399956., 427700., 456212., 485492., 305848., 325368., 345400., 365944.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   446.,   846.,   380.,   1180.,  2236.,  3548.,
      1724.,  3036.,  4604.,  6428.,  2558.,  3470.,  4510.,  5678.,
      860.,   2428.,  4252.,  6332.,  7480.,  11640., 16312., 21496.,
      14264., 19448., 25144., 31352., 13084., 16188., 19548., 23164.,
      7964.,  11068., 14428., 18044., 27832., 35064., 42808., 51064.,
      34616., 42872., 51640., 60920., 26332., 30972., 35868., 41020.,
      13598., 15790., 18110., 20558., 35708., 40604., 45756., 51164.,
      41148., 46556., 52220., 58140., 26366., 29326., 32414., 35630.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,  68.,  89.,  110., 96.,  114., 219., 264., 309., 252.,
      249., 444., 489., 534., 417., 320., 539., 578., 617., 460.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,  4.,  10., 12.,  9.,  8.,   26.,
                                         56., 54., 36., 23.,  62., 119., 102.,
                                         63., 28., 67., 118., 93., 54.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,  454.,  610.,  766.,  684.,  786.,  1545., 1887., 2229., 1842.,
      1806., 3255., 3597., 3939., 3102., 2404., 4066., 4366., 4666., 3492.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   22.,  59.,  78.,  61.,  46.,  164., 370., 372., 254.,
      154., 428., 838., 732., 458., 203., 490., 869., 690., 403.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,  3284.,  4484.,  5684.,  5144.,  5796.,  11550.,
      14214., 16878., 14052., 13716., 24870., 27534., 30198.,
      23892., 18616., 31556., 33908., 36260., 27192.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,  394.,  556.,  446.,  300.,  1144., 2660., 2744., 1900.,
      1116., 3160., 6260., 5528., 3484., 1542., 3740., 6658., 5308., 3110.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76.,   128.,  182.,  272.,  254.,  356.,  326.,  440.,  300.,  384.,
      330.,  456.,  669.,  876.,  831.,  1056., 993.,  1236., 834.,  1008.,
      810.,  996.,  1479., 1776., 1641., 1956., 1803., 2136., 1434., 1668.,
      1124., 1280., 1910., 2156., 2054., 2312., 2198., 2468., 1652., 1840.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   6.,   16.,  19.,  40.,  30.,  48.,  25.,  36.,
      14., 32.,  60.,  104., 146., 224., 156., 216., 110., 144.,
      62., 92.,  180., 248., 362., 476., 324., 408., 206., 252.,
      91., 112., 222., 268., 397., 472., 318., 372., 187., 216.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      516.,   916.,   1294.,  1990.,  1846.,  2638.,  2398.,  3286.,
      2244.,  2900.,  2406.,  3390.,  4965.,  6585.,  6225.,  7989.,
      7485.,  9393.,  6342.,  7710.,  6126.,  7590.,  11265., 13605.,
      12525., 15009., 13785., 16413., 11022., 12870., 8692.,  9924.,
      14806., 16750., 15934., 17974., 17062., 19198., 12852., 14340.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   25.,  34.,   106.,  119.,  275.,  210.,  346.,  181.,  265.,
      82.,  218., 404.,  740.,  1030., 1630., 1140., 1604., 818.,  1082.,
      442., 674., 1316., 1844., 2686., 3574., 2436., 3092., 1562., 1922.,
      689., 853., 1690., 2050., 3035., 3623., 2442., 2866., 1441., 1669.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3768.,   6904.,   9716.,   15188.,  14036.,  20276.,  18356.,  25364.,
      17336.,  22520.,  18324.,  26100.,  38190.,  51006.,  48126.,  62094.,
      58062.,  73182.,  49428.,  60276.,  47604.,  59220.,  87870.,  106446.,
      97806.,  117534., 107742., 128622., 86388.,  101076., 68344.,  78136.,
      116564., 132020., 125492., 141716., 134420., 151412., 101368., 113208.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   220.,   764.,   826.,   2026.,  1564.,  2620.,
      1374.,  2030.,  540.,   1596.,  2936.,  5560.,  7700.,  12404.,
      8696.,  12344., 6300.,  8380.,  3324.,  5148.,  10040., 14200.,
      20660., 27668., 18872., 24056., 12156., 15004., 5358.,  6654.,
      13180., 16028., 23722., 28378., 19132., 22492., 11310., 13118.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      212.,  304.,  404.,  512.,  566.,  728.,  902.,  1088., 830.,  1016.,
      1214., 1424., 1094., 1304., 1526., 1760., 1044., 1200., 1364., 1536.,
      1086., 1320., 1566., 1824., 2289., 2676., 3081., 3504., 2901., 3324.,
      3765., 4224., 3513., 3972., 4449., 4944., 3006., 3336., 3678., 4032.,
      2886., 3240., 3606., 3984., 5349., 5916., 6501., 7104., 5961., 6564.,
      7185., 7824., 6573., 7212., 7869., 8544., 5286., 5736., 6198., 6672.,
      4196., 4496., 4804., 5120., 7166., 7640., 8126., 8624., 7718., 8216.,
      8726., 9248., 8270., 8792., 9326., 9872., 6244., 6608., 6980., 7360.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,  64.,   43.,   76.,
      115.,  160.,  90.,   120.,  154.,  192.,  81.,  100.,  121.,  144.,
      26.,   56.,   90.,   128.,  164.,  240.,  324., 416.,  446.,  584.,
      734.,  896.,  516.,  624.,  740.,  864.,  378., 440.,  506.,  576.,
      194.,  248.,  306.,  368.,  596.,  720.,  852., 992.,  1238., 1448.,
      1670., 1904., 1140., 1296., 1460., 1632., 738., 824.,  914.,  1008.,
      325.,  364.,  405.,  448.,  802.,  888.,  978., 1072., 1447., 1588.,
      1735., 1888., 1170., 1272., 1378., 1488., 693., 748.,  805.,  864.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1524.,  2244.,  3028.,  3876.,  4222.,  5494.,  6862.,  8326.,  6286.,
      7750.,  9310.,  10966., 8350.,  10006., 11758., 13606., 8052.,  9284.,
      10580., 11940., 8238.,  10086., 12030., 14070., 17565., 20625., 23829.,
      27177., 22389., 25737., 29229., 32865., 27213., 30849., 34629., 38553.,
      23406., 26022., 28734., 31542., 22398., 25206., 28110., 31110., 41685.,
      46185., 50829., 55617., 46509., 51297., 56229., 61305., 51333., 56409.,
      61629., 66993., 41406., 44982., 48654., 52422., 32980., 35364., 37812.,
      40324., 56398., 60166., 64030., 67990., 60766., 64726., 68782., 72934.,
      65134., 69286., 73534., 77878., 49236., 52132., 55092., 58116.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   287.,
      539.,   839.,   1187.,  666.,   898.,   1162.,  1458.,  613.,   761.,
      925.,   1105.,  154.,   386.,   650.,   946.,   1172.,  1764.,  2420.,
      3140.,  3310.,  4390.,  5566.,  6838.,  3924.,  4772.,  5684.,  6660.,
      2906.,  3394.,  3914.,  4466.,  1450.,  1874.,  2330.,  2818.,  4532.,
      5508.,  6548.,  7652.,  9502.,  11158., 12910., 14758., 8820.,  10052.,
      11348., 12708., 5738.,  6418.,  7130.,  7874.,  2525.,  2833.,  3157.,
      3497.,  6250.,  6930.,  7642.,  8386.,  11303., 12419., 13583., 14795.,
      9162.,  9970.,  10810., 11682., 5437.,  5873.,  6325.,  6793.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11512.,  17208.,  23416.,  30136.,  32564.,  42644.,  53492.,  65108.,
      48884.,  60500.,  72884.,  86036.,  65204.,  78356.,  92276.,  106964.,
      63224.,  73016.,  83320.,  94136.,  64116.,  78804.,  94260.,  110484.,
      137550., 161886., 187374., 214014., 175854., 202494., 230286., 259230.,
      214158., 243102., 273198., 304446., 184692., 205524., 227124., 249492.,
      176436., 198804., 221940., 245844., 329070., 364926., 401934., 440094.,
      367374., 405534., 444846., 485310., 405678., 446142., 487758., 530526.,
      327732., 356244., 385524., 415572., 261496., 280504., 300024., 320056.,
      447476., 477524., 508340., 539924., 482228., 513812., 546164., 579284.,
      516980., 550100., 583988., 618644., 391032., 414136., 437752., 461880.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   446.,    846.,    380.,   1180.,  2236.,   3548.,
      2074.,  4042.,  6394.,   9130.,   5116.,  6940.,  9020.,   11356.,
      4766.,  5934.,  7230.,   8654.,   1020.,  2844.,  4924.,   7260.,
      8824.,  13496., 18680.,  24376.,  25460., 34004., 43316.,  53396.,
      30584., 37304., 44536.,  52280.,  22780., 26652., 30780.,  35164.,
      11196., 14556., 18172.,  22044.,  35320., 43064., 51320.,  60088.,
      74420., 87572., 101492., 116180., 69368., 79160., 89464.,  100280.,
      45244., 50652., 56316.,  62236.,  19902., 22350., 24926.,  27630.,
      49340., 54748., 60412.,  66332.,  89338., 98218., 107482., 117130.,
      72508., 78940., 85628.,  92572.,  43070., 46542., 50142.,  53870.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,  74.,  95.,  116., 137., 117., 129., 246., 291., 336., 381., 306.,
      291., 516., 561., 606., 651., 504., 377., 632., 671., 710., 749., 555.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,  10.,  16.,  17.,  12., 9.,  29., 62.,  83.,  75.,  48.,
      27., 71., 134., 173., 141., 84., 35., 82., 142., 166., 127., 72.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,  496.,  652.,  808.,  964.,  840.,  894.,  1743.,
      2085., 2427., 2769., 2250., 2118., 3795., 4137., 4479.,
      4821., 3762., 2840., 4780., 5080., 5380., 5680., 4224.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,   22.,  59.,   101.,  114.,  83.,
                                         52.,  184., 412.,  568.,  528.,  344.,
                                         184., 496., 952.,  1252., 1032., 620.,
                                         257., 606., 1055., 1241., 954.,  543.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,  3596.,  4796.,  5996.,  7196.,  6344.,  6612.,  13062.,
      15726., 18390., 21054., 17220., 16116., 29046., 31710., 34374.,
      37038., 29028., 22024., 37148., 39500., 41852., 44204., 32936.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,  394.,  706.,  828.,  614.,  340.,  1288.,
      2972., 4172., 3944., 2596., 1348., 3688., 7148., 9500.,
      7880., 4756., 1966., 4652., 8122., 9586., 7388., 4214.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84.,   140.,  200.,  296.,  272.,  380.,  344.,  464.,  416.,  548.,
      372.,  468.,  378.,  516.,  759.,  984.,  921.,  1164., 1083., 1344.,
      1245., 1524., 1026., 1224., 954.,  1164., 1731., 2064., 1893., 2244.,
      2055., 2424., 2217., 2604., 1746., 2016., 1332., 1508., 2252., 2528.,
      2396., 2684., 2540., 2840., 2684., 2996., 2004., 2220.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   6.,   16.,  19.,  40.,  37.,  64.,  46.,  68.,  35.,  48.,
      16.,  36.,  68.,  116., 164., 248., 236., 332., 228., 300., 152., 192.,
      76.,  108., 212., 284., 416., 536., 560., 692., 468., 564., 284., 336.,
      117., 140., 278., 328., 487., 568., 577., 664., 446., 508., 255., 288.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      572.,   1004.,  1426.,  2170.,  1978.,  2818.,  2530.,  3466.,
      3082.,  4114.,  2796.,  3548.,  2766.,  3846.,  5649.,  7413.,
      6909.,  8817.,  8169.,  10221., 9429.,  11625., 7830.,  9390.,
      7230.,  8886.,  13209., 15837., 14469., 17241., 15729., 18645.,
      16989., 20049., 13446., 15582., 10316., 11708., 17482., 19666.,
      18610., 20890., 19738., 22114., 20866., 23338., 15612., 17324.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    25.,   34.,   106.,  119.,  275.,  251.,  455.,  330.,  498.,
      257.,  357.,  94.,   246.,  460.,  828.,  1162., 1810., 1714., 2458.,
      1692., 2252., 1142., 1454., 550.,  798.,  1564., 2124., 3106., 4042.,
      4234., 5266., 3564., 4316., 2174., 2582., 893.,  1073., 2130., 2522.,
      3743., 4379., 4451., 5135., 3450., 3938., 1977., 2237.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4184.,   7576.,   10724.,  16580.,  15044.,  21668.,  19364.,  26756.,
      23684.,  31844.,  21656.,  27608.,  21108.,  29652.,  43518.,  57486.,
      53454.,  68574.,  63390.,  79662.,  73326.,  90750.,  61140.,  73524.,
      56244.,  69396.,  103134., 124014., 113070., 135102., 123006., 146190.,
      132942., 157278., 105492., 122484., 81176.,  92248.,  137732., 155108.,
      146660., 164804., 155588., 174500., 164516., 184196., 123224., 136856.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   220.,   764.,   826.,   2026.,  1834.,  3418.,
      2492.,  3804.,  1966.,  2750.,  620.,   1804.,  3352.,  6232.,
      8708.,  13796., 13028., 18884., 13016., 17432., 8844.,  11308.,
      4172.,  6124.,  11992., 16408., 23972., 31364., 32900., 41060.,
      27800., 33752., 17004., 20236., 6974.,  8398.,  16668., 19772.,
      29338., 34378., 34954., 40378., 27132., 31004., 15566., 17630.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236.,   336.,   444.,   560.,  626.,   800.,   986.,   1184.,  890.,
      1088.,  1298.,  1520.,  1154., 1376.,  1610.,  1856.,  1418.,  1664.,
      1922.,  2192.,  1308.,  1488., 1676.,  1872.,  1254.,  1512.,  1782.,
      2064.,  2613.,  3036.,  3477., 3936.,  3225.,  3684.,  4161.,  4656.,
      3837.,  4332.,  4845.,  5376., 4449.,  4980.,  5529.,  6096.,  3726.,
      4104.,  4494.,  4896.,  3414., 3816.,  4230.,  4656.,  6285.,  6924.,
      7581.,  8256.,  6897.,  7572., 8265.,  8976.,  7509.,  8220.,  8949.,
      9696.,  8121.,  8868.,  9633., 10416., 6462.,  6984.,  7518.,  8064.,
      4988.,  5328.,  5676.,  6032., 8474.,  9008.,  9554.,  10112., 9026.,
      9584.,  10154., 10736., 9578., 10160., 10754., 11360., 10130., 10736.,
      11354., 11984., 7596.,  8016., 8444.,  8880.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   43.,   76.,
      115.,  160.,  103.,  148.,  199.,  256.,  146.,  184.,  226.,  272.,
      117.,  140.,  165.,  192.,  30.,   64.,   102.,  144.,  188.,  272.,
      364.,  464.,  506.,  656.,  818.,  992.,  770.,  944.,  1130., 1328.,
      780.,  912.,  1052., 1200., 534.,  608.,  686.,  768.,  246.,  304.,
      366.,  432.,  716.,  848.,  988.,  1136., 1442., 1664., 1898., 2144.,
      1994., 2240., 2498., 2768., 1692., 1872., 2060., 2256., 1038., 1136.,
      1238., 1344., 425.,  468.,  513.,  560.,  1018., 1112., 1210., 1312.,
      1795., 1948., 2107., 2272., 2143., 2308., 2479., 2656., 1666., 1784.,
      1906., 2032., 957.,  1020., 1085., 1152.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1700.,  2484.,  3332.,  4244.,  4678.,  6046.,  7510.,  9070.,  6742.,
      8302.,  9958.,  11710., 8806.,  10558., 12406., 14350., 10870., 12814.,
      14854., 16990., 10116., 11540., 13028., 14580., 9534.,  11574., 13710.,
      15942., 20085., 23433., 26925., 30561., 24909., 28545., 32325., 36249.,
      29733., 33657., 37725., 41937., 34557., 38769., 43125., 47625., 29070.,
      32070., 35166., 38358., 26526., 29718., 33006., 36390., 49029., 54105.,
      59325., 64689., 53853., 59217., 64725., 70377., 58677., 64329., 70125.,
      76065., 63501., 69441., 75525., 81753., 50670., 54822., 59070., 63414.,
      39236., 41940., 44708., 47540., 66742., 70990., 75334., 79774., 71110.,
      75550., 80086., 84718., 75478., 80110., 84838., 89662., 79846., 84670.,
      89590., 94606., 59940., 63284., 66692., 70164.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   287.,
      539.,   839.,   1187.,  743.,   1091.,  1487.,  1931.,  1098.,  1394.,
      1722.,  2082.,  893.,   1073.,  1269.,  1481.,  178.,   442.,   738.,
      1066.,  1348.,  2004.,  2724.,  3508.,  3766.,  4942.,  6214.,  7582.,
      5830.,  7198.,  8662.,  10222., 5988.,  7028.,  8132.,  9300.,  4130.,
      4714.,  5330.,  5978.,  1858.,  2314.,  2802.,  3322.,  5476.,  6516.,
      7620.,  8788.,  11110., 12862., 14710., 16654., 15478., 17422., 19462.,
      21598., 13188., 14612., 16100., 17652., 8114.,  8890.,  9698.,  10538.,
      3317.,  3657.,  4013.,  4385.,  7962.,  8706.,  9482.,  10290., 14063.,
      15275., 16535., 17843., 16823., 18131., 19487., 20891., 13098., 14034.,
      15002., 16002., 7533.,  8033.,  8549.,  9081.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12856.,  19064.,  25784.,  33016.,  36116.,  46964.,  58580.,  70964.,
      52436.,  64820.,  77972.,  91892.,  68756.,  82676.,  97364.,  112820.,
      85076.,  100532., 116756., 133748., 79544.,  90872.,  102712., 115064.,
      74292.,  90516.,  107508., 125268., 157422., 184062., 211854., 240798.,
      195726., 224670., 254766., 286014., 234030., 265278., 297678., 331230.,
      272334., 305886., 340590., 376446., 229620., 253524., 278196., 303636.,
      209076., 234516., 260724., 287700., 387246., 427710., 469326., 512094.,
      425550., 468318., 512238., 557310., 463854., 508926., 555150., 602526.,
      502158., 549534., 598062., 647742., 401268., 434388., 468276., 502932.,
      311224., 332792., 354872., 377464., 529748., 563636., 598292., 633716.,
      564500., 599924., 636116., 673076., 599252., 636212., 673940., 712436.,
      634004., 672500., 711764., 751796., 476216., 502904., 530104., 557816.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      2074.,   4042.,   6394.,   9130.,   5626.,   8362.,   11482.,  14986.,
      8508.,   10844.,  13436.,  16284.,  6974.,   8398.,   9950.,   11630.,
      1180.,   3260.,   5596.,   8188.,   10168.,  15352.,  21048.,  27256.,
      29012.,  38324.,  48404.,  59252.,  45332.,  56180.,  67796.,  80180.,
      46904.,  55160.,  63928.,  73208.,  32476.,  37116.,  42012.,  47164.,
      14428.,  18044.,  21916.,  26044.,  42808.,  51064.,  59832.,  69112.,
      87188.,  101108., 115796., 131252., 121940., 137396., 153620., 170612.,
      104120., 115448., 127288., 139640., 64156.,  70332.,  76764.,  83452.,
      26206.,  28910.,  31742.,  34702.,  62972.,  68892.,  75068.,  81500.,
      111322., 120970., 131002., 141418., 133306., 143722., 154522., 165706.,
      103868., 111324., 119036., 127004., 59774.,  63758.,  67870.,  72110.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  62.,  83.,  75.,  99.,  192., 237., 198., 207., 372.,
      417., 330., 315., 552., 597., 462., 359., 602., 641., 477.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1.,   4.,  7.,  6.,  7.,  23., 33.,
                                         24.,  24., 69., 90., 60., 41., 101.,
                                         119., 72., 35., 82., 93., 54.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,  412.,  568.,  528.,  678.,  1347., 1689., 1434., 1494., 2715.,
      3057., 2442., 2310., 4083., 4425., 3450., 2704., 4552., 4852., 3624.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   22.,  42.,  39.,  40.,  144., 216., 164., 153., 462.,
      618., 423., 292., 728., 864., 528., 257., 606., 690., 403.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,  4172.,  3944.,  4980.,  10038., 12702.,
      10884., 11316., 20694., 23358., 18756., 17652., 31350.,
      34014., 26628., 20968., 35372., 37724., 28232.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,  284.,  278.,  260.,  1000., 1544., 1204., 1074., 3348.,
      4548., 3162., 2196., 5512., 6568., 4036., 1966., 4652., 5308., 3110.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68.,   116.,  164.,  248.,  236.,  332.,  228.,  300.,  282.,  396.,
      579.,  768.,  741.,  948.,  642.,  792.,  666.,  828.,  1227., 1488.,
      1389., 1668., 1122., 1320., 1050., 1260., 1875., 2208., 2037., 2388.,
      1602., 1848., 1268., 1436., 2144., 2408., 2288., 2564., 1716., 1908.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   6.,   16.,  14.,  28.,  15.,  24.,  12.,  28.,
      52.,  92.,  84.,  132., 68.,  96.,  57.,  96.,  186., 276.,
      258., 360., 183., 240., 128., 164., 324., 404., 388., 476.,
      240., 288., 117., 140., 278., 328., 318., 372., 187., 216.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      460.,  828.,   1162.,  1810.,  1714.,  2458.,  1692.,  2252.,
      2046., 2934.,  4281.,  5757.,  5541.,  7161.,  4854.,  6030.,
      5022., 6294.,  9321.,  11373., 10581., 12777., 8598.,  10158.,
      7998., 9654.,  14361., 16989., 15621., 18393., 12342., 14286.,
      9820., 11148., 16642., 18730., 17770., 19954., 13356., 14876.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    25.,   34.,   106.,  90.,   194.,  105.,  173.,  70.,   190.,
      348.,  652.,  588.,  956.,  494.,  710.,  387.,  687.,  1326., 2022.,
      1878., 2670., 1359., 1803., 958.,  1238., 2444., 3068., 2940., 3628.,
      1830., 2206., 893.,  1073., 2130., 2522., 2442., 2866., 1441., 1669.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3352.,  6232.,  8708.,   13796.,  13028.,  18884.,  13016.,  17432.,
      15540., 22548., 32862.,  44526.,  42798.,  55614.,  37716.,  47028.,
      38964., 49044., 72606.,  88878.,  82542.,  99966.,  67284.,  79668.,
      62388., 75540., 112350., 133230., 122286., 144318., 96852.,  112308.,
      77272., 87832., 131108., 147716., 140036., 157412., 105368., 117464.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   174.,  220.,   764.,   636.,   1436.,  782.,   1310.,
      460.,  1388., 2520.,  4888.,  4376.,  7256.,  3756.,  5452.,
      2826., 5178., 9972.,  15444., 14292., 20532., 10458., 13962.,
      7404., 9612., 18968., 23896., 22872., 28312., 14284., 17260.,
      6974., 8398., 16668., 19772., 19132., 22492., 11310., 13118.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      188.,  272.,  364.,  464.,  506.,  656.,   818.,  992.,  770.,  944.,
      1130., 1328., 780.,  912.,  1052., 1200.,  918.,  1128., 1350., 1584.,
      1965., 2316., 2685., 3072., 2577., 2964.,  3369., 3792., 2286., 2568.,
      2862., 3168., 2358., 2664., 2982., 3312.,  4413., 4908., 5421., 5952.,
      5025., 5556., 6105., 6672., 4110., 4488.,  4878., 5280., 3798., 4200.,
      4614., 5040., 6861., 7500., 8157., 8832.,  7473., 8148., 8841., 9552.,
      5934., 6408., 6894., 7392., 4748., 5072.,  5404., 5744., 8066., 8576.,
      9098., 9632., 8618., 9152., 9698., 10256., 6492., 6864., 7244., 7632.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   34.,   56.,
      82.,   112.,  45.,   60.,   77.,   96.,   22.,   48.,   78.,   112.,
      140.,  208.,  284.,  368.,  252.,  336.,  428.,  528.,  222.,  272.,
      326.,  384.,  159.,  228.,  303.,  384.,  582.,  744.,  918.,  1104.,
      846.,  1032., 1230., 1440., 627.,  732.,  843.,  960.,  446.,  512.,
      582.,  656.,  1148., 1296., 1452., 1616., 1388., 1552., 1724., 1904.,
      870.,  960.,  1054., 1152., 425.,  468.,  513.,  560.,  1018., 1112.,
      1210., 1312., 1170., 1272., 1378., 1488., 693.,  748.,  805.,  864.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1348.,  2004.,  2724.,  3508.,  3766.,  4942.,  6214.,  7582.,  5830.,
      7198.,  8662.,  10222., 5988.,  7028.,  8132.,  9300.,  6942.,  8598.,
      10350., 12198., 15045., 17817., 20733., 23793., 19869., 22929., 26133.,
      29481., 17742., 19974., 22302., 24726., 18270., 20694., 23214., 25830.,
      34341., 38265., 42333., 46545., 39165., 43377., 47733., 52233., 32142.,
      35142., 38238., 41430., 29598., 32790., 36078., 39462., 53637., 58713.,
      63933., 69297., 58461., 63825., 69333., 74985., 46542., 50310., 54174.,
      58134., 37348., 39924., 42564., 45268., 63526., 67582., 71734., 75982.,
      67894., 72142., 76486., 80926., 51204., 54164., 57188., 60276.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,  466.,   234.,
      402.,   602.,   834.,   333.,   449.,   581.,   729.,  130.,   330.,
      562.,   826.,   996.,   1524.,  2116.,  2772.,  1860., 2516.,  3236.,
      4020.,  1682.,  2074.,  2498.,  2954.,  1143.,  1683., 2271.,  2907.,
      4350.,  5622.,  6990.,  8454.,  6414.,  7878.,  9438., 11094., 4815.,
      5643.,  6519.,  7443.,  3442.,  3962.,  4514.,  5098., 8900.,  10068.,
      11300., 12596., 10788., 12084., 13444., 14868., 6786., 7498.,  8242.,
      9018.,  3317.,  3657.,  4013.,  4385.,  7962.,  8706., 9482.,  10290.,
      9162.,  9970.,  10810., 11682., 5437.,  5873.,  6325., 6793.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10168.,  15352.,  21048.,  27256.,  29012.,  38324.,  48404.,  59252.,
      45332.,  56180.,  67796.,  80180.,  46904.,  55160.,  63928.,  73208.,
      53940.,  67092.,  81012.,  95700.,  117678., 139710., 162894., 187230.,
      155982., 180318., 205806., 232446., 139764., 157524., 176052., 195348.,
      143796., 163092., 183156., 203988., 270894., 302142., 334542., 368094.,
      309198., 342750., 377454., 413310., 254196., 278100., 302772., 328212.,
      233652., 259092., 285300., 312276., 424110., 464574., 506190., 548958.,
      462414., 505182., 549102., 594174., 368628., 398676., 429492., 461076.,
      296248., 316792., 337848., 359416., 504212., 536564., 569684., 603572.,
      538964., 572852., 607508., 642932., 406712., 430328., 454456., 479096.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   446.,   846.,   380.,    1180.,   2236.,  3548.,  1724.,
      3036.,  4604.,  6428.,  2558.,  3470.,   4510.,   5678.,  860.,   2428.,
      4252.,  6332.,  7480.,  11640., 16312.,  21496.,  14264., 19448., 25144.,
      31352., 13084., 16188., 19548., 23164.,  8634.,   12906., 17562., 22602.,
      33588., 43668., 54516., 66132., 49908.,  61524.,  73908., 87060., 37722.,
      44298., 51258., 58602., 27036., 31164.,  35548.,  40188., 70072., 79352.,
      89144., 99448., 85048., 95352., 106168., 117496., 53596., 59260., 65180.,
      71356., 26206., 28910., 31742., 34702.,  62972.,  68892., 75068., 81500.,
      72508., 78940., 85628., 92572., 43070.,  46542.,  50142., 53870.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,  68.,  89.,  110., 96.,  114., 219., 264., 309.,
      252., 249., 444., 489., 534., 417., 384., 669., 714.,
      759., 582., 440., 734., 773., 812., 600.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,  10., 12.,  9.,   8.,   26.,  56., 54.,  36.,  30.,  84., 165.,
      144., 90., 56., 134., 236., 186., 108., 49., 112., 190., 144., 81.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,  454.,  610.,  766.,  684.,  786.,  1545., 1887., 2229.,
      1842., 1806., 3255., 3597., 3939., 3102., 2826., 4965., 5307.,
      5649., 4362., 3324., 5566., 5866., 6166., 4572.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,  59.,  78.,   61.,   46.,   164., 370., 372.,
      254.,  195., 570., 1149., 1026., 651.,  406., 980., 1738.,
      1380., 806., 365., 838.,  1427., 1086., 613.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,  3284.,  4484.,  5684.,  5144.,  5796.,  11550., 14214., 16878.,
      14052., 13716., 24870., 27534., 30198., 23892., 21636., 38190., 40854.,
      43518., 33732., 25816., 43316., 45668., 48020., 35672.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,  394.,  556.,  446.,   300.,  1144., 2660., 2744.,
      1900.,  1386., 4164., 8526., 7716.,  4938., 3084., 7480., 13316.,
      10616., 6220., 2814., 6476., 11050., 8428., 4766.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76.,   128.,  182.,  272.,  254.,  356.,  326.,  440.,  300.,  384.,
      330.,  456.,  669.,  876.,  831.,  1056., 993.,  1236., 834.,  1008.,
      810.,  996.,  1479., 1776., 1641., 1956., 1803., 2136., 1434., 1668.,
      1290., 1536., 2289., 2676., 2451., 2856., 2613., 3036., 2034., 2328.,
      1564., 1760., 2630., 2936., 2774., 3092., 2918., 3248., 2172., 2400.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   6.,   16.,  19.,  40.,  30.,  48.,  25.,  36.,
      14.,  32.,  60.,  104., 146., 224., 156., 216., 110., 144.,
      75.,  120., 234., 336., 489., 660., 450., 576., 291., 360.,
      182., 224., 444., 536., 794., 944., 636., 744., 374., 432.,
      169., 196., 390., 448., 667., 760., 510., 576., 289., 324.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      516.,   916.,   1294.,  1990.,  1846.,  2638.,  2398.,  3286.,  2244.,
      2900.,  2406.,  3390.,  4965.,  6585.,  6225.,  7989.,  7485.,  9393.,
      6342.,  7710.,  6126.,  7590.,  11265., 13605., 12525., 15009., 13785.,
      16413., 11022., 12870., 9846.,  11790., 17565., 20625., 18825., 22029.,
      20085., 23433., 15702., 18030., 12132., 13684., 20446., 22870., 21574.,
      24094., 22702., 25318., 16932., 18740.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    25.,   34.,   106.,  119.,  275.,  210.,  346.,  181.,  265.,
      82.,   218.,  404.,  740.,  1030., 1630., 1140., 1604., 818.,  1082.,
      519.,  867.,  1686., 2478., 3597., 4929., 3366., 4350., 2199., 2739.,
      1378., 1706., 3380., 4100., 6070., 7246., 4884., 5732., 2882., 3338.,
      1301., 1513., 3010., 3466., 5159., 5891., 3954., 4474., 2245., 2521.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3768.,   6904.,   9716.,   15188.,  14036.,  20276.,  18356.,  25364.,
      17336.,  22520.,  18324.,  26100.,  38190.,  51006.,  48126.,  62094.,
      58062.,  73182.,  49428.,  60276.,  47604.,  59220.,  87870.,  106446.,
      97806.,  117534., 107742., 128622., 86388.,  101076., 76884.,  92340.,
      137550., 161886., 147486., 172974., 157422., 184062., 123348., 141876.,
      95544.,  107896., 161204., 180500., 170132., 190196., 179060., 199892.,
      133688., 148088.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   220.,   764.,   826.,   2026.,  1564.,  2620.,  1374.,
      2030.,  540.,   1596.,  2936.,  5560.,  7700.,  12404., 8696.,  12344.,
      6300.,  8380.,  3834.,  6570.,  12756., 18996., 27534., 38046., 26004.,
      33780., 17082., 21354., 10716., 13308., 26360., 32056., 47444., 56756.,
      38264., 44984., 22620., 26236., 10206., 11886., 23644., 27260., 40570.,
      46378., 31132., 35260., 17694., 19886.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      212.,   304.,   404.,   512.,   566.,   728.,   902.,   1088.,  830.,
      1016.,  1214.,  1424.,  1094.,  1304.,  1526.,  1760.,  1044.,  1200.,
      1364.,  1536.,  1086.,  1320.,  1566.,  1824.,  2289.,  2676.,  3081.,
      3504.,  2901.,  3324.,  3765.,  4224.,  3513.,  3972.,  4449.,  4944.,
      3006.,  3336.,  3678.,  4032.,  2886.,  3240.,  3606.,  3984.,  5349.,
      5916.,  6501.,  7104.,  5961.,  6564.,  7185.,  7824.,  6573.,  7212.,
      7869.,  8544.,  5286.,  5736.,  6198.,  6672.,  4686.,  5160.,  5646.,
      6144.,  8409.,  9156.,  9921.,  10704., 9021.,  9804.,  10605., 11424.,
      9633.,  10452., 11289., 12144., 7566.,  8136.,  8718.,  9312.,  5876.,
      6256.,  6644.,  7040.,  9926.,  10520., 11126., 11744., 10478., 11096.,
      11726., 12368., 11030., 11672., 12326., 12992., 8244.,  8688.,  9140.,
      9600.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   43.,   76.,
      115.,  160.,  90.,   120.,  154.,  192.,  81.,   100.,  121.,  144.,
      26.,   56.,   90.,   128.,  164.,  240.,  324.,  416.,  446.,  584.,
      734.,  896.,  516.,  624.,  740.,  864.,  378.,  440.,  506.,  576.,
      219.,  300.,  387.,  480.,  750.,  936.,  1134., 1344., 1641., 1956.,
      2289., 2640., 1566., 1800., 2046., 2304., 1035., 1164., 1299., 1440.,
      650.,  728.,  810.,  896.,  1604., 1776., 1956., 2144., 2894., 3176.,
      3470., 3776., 2340., 2544., 2756., 2976., 1386., 1496., 1610., 1728.,
      625.,  676.,  729.,  784.,  1450., 1560., 1674., 1792., 2491., 2668.,
      2851., 3040., 1914., 2040., 2170., 2304., 1089., 1156., 1225., 1296.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1524.,  2244.,  3028.,  3876.,  4222.,  5494.,   6862.,  8326.,  6286.,
      7750.,  9310.,  10966., 8350.,  10006., 11758.,  13606., 8052.,  9284.,
      10580., 11940., 8238.,  10086., 12030., 14070.,  17565., 20625., 23829.,
      27177., 22389., 25737., 29229., 32865., 27213.,  30849., 34629., 38553.,
      23406., 26022., 28734., 31542., 22398., 25206.,  28110., 31110., 41685.,
      46185., 50829., 55617., 46509., 51297., 56229.,  61305., 51333., 56409.,
      61629., 66993., 41406., 44982., 48654., 52422.,  36558., 40326., 44190.,
      48150., 65805., 71745., 77829., 84057., 70629.,  76857., 83229., 89745.,
      75453., 81969., 88629., 95433., 59406., 63942.,  68574., 73302., 46260.,
      49284., 52372., 55524., 78238., 82966., 87790.,  92710., 82606., 87526.,
      92542., 97654., 86974., 92086., 97294., 102598., 65076., 68612., 72212.,
      75876.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   287.,
      539.,   839.,   1187.,  666.,   898.,   1162.,  1458.,  613.,   761.,
      925.,   1105.,  154.,   386.,   650.,   946.,   1172.,  1764.,  2420.,
      3140.,  3310.,  4390.,  5566.,  6838.,  3924.,  4772.,  5684.,  6660.,
      2906.,  3394.,  3914.,  4466.,  1599.,  2235.,  2919.,  3651.,  5646.,
      7110.,  8670.,  10326., 12525., 15009., 17637., 20409., 12078., 13926.,
      15870., 17910., 8031.,  9051.,  10119., 11235., 5050.,  5666.,  6314.,
      6994.,  12500., 13860., 15284., 16772., 22606., 24838., 27166., 29590.,
      18324., 19940., 21620., 23364., 10874., 11746., 12650., 13586., 4901.,
      5305.,  5725.,  6161.,  11386., 12258., 13162., 14098., 19583., 20987.,
      22439., 23939., 15066., 16066., 17098., 18162., 8581.,  9113.,  9661.,
      10225.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11512.,  17208.,  23416.,  30136.,  32564.,  42644.,  53492.,  65108.,
      48884.,  60500.,  72884.,  86036.,  65204.,  78356.,  92276.,  106964.,
      63224.,  73016.,  83320.,  94136.,  64116.,  78804.,  94260.,  110484.,
      137550., 161886., 187374., 214014., 175854., 202494., 230286., 259230.,
      214158., 243102., 273198., 304446., 184692., 205524., 227124., 249492.,
      176436., 198804., 221940., 245844., 329070., 364926., 401934., 440094.,
      367374., 405534., 444846., 485310., 405678., 446142., 487758., 530526.,
      327732., 356244., 385524., 415572., 288756., 318804., 349620., 381204.,
      520590., 567966., 616494., 666174., 558894., 608574., 659406., 711390.,
      597198., 649182., 702318., 756606., 470772., 506964., 543924., 581652.,
      367096., 391224., 415864., 441016., 621236., 658964., 697460., 736724.,
      655988., 695252., 735284., 776084., 690740., 731540., 773108., 815444.,
      517112., 545336., 574072., 603320.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      2074.,   4042.,   6394.,   9130.,   5116.,   6940.,   9020.,   11356.,
      4766.,   5934.,   7230.,   8654.,   1020.,   2844.,   4924.,   7260.,
      8824.,   13496.,  18680.,  24376.,  25460.,  34004.,  43316.,  53396.,
      30584.,  37304.,  44536.,  52280.,  22780.,  26652.,  30780.,  35164.,
      12186.,  17226.,  22650.,  28458.,  43764.,  55380.,  67764.,  80916.,
      97806.,  117534., 138414., 160446., 94836.,  109524., 124980., 141204.,
      63258.,  71370.,  79866.,  88746.,  39804.,  44700.,  49852.,  55260.,
      98680.,  109496., 120824., 132664., 178676., 196436., 214964., 234260.,
      145016., 157880., 171256., 185144., 86140.,  93084.,  100284., 107740.,
      38814.,  42030.,  45374.,  48846.,  90236.,  97180.,  104380., 111836.,
      155290., 166474., 178042., 189994., 119548., 127516., 135740., 144220.,
      68126.,  72366.,  76734.,  81230.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,  74.,  95.,  116., 137., 117., 129., 246., 291., 336.,
      381., 306., 291., 516., 561., 606., 651., 504., 453., 786.,
      831., 876., 921., 702., 521., 866., 905., 944., 983., 723.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  16.,  17.,  12.,  9.,   29.,  62.,  83.,
      75.,  48.,  36.,  99.,  192., 237., 198., 120., 71.,  167.,
      290., 329., 253., 144., 63.,  142., 238., 262., 195., 108.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,  496.,  652.,  808.,  964.,  840.,  894.,  1743., 2085., 2427.,
      2769., 2250., 2118., 3795., 4137., 4479., 4821., 3762., 3342., 5847.,
      6189., 6531., 6873., 5274., 3944., 6580., 6880., 7180., 7480., 5520.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   101.,  114.,  83.,   52.,   184.,  412.,  568.,
      528.,  344.,  237.,  678.,  1347., 1689., 1434., 879.,  520.,  1232.,
      2152., 2452., 1896., 1084., 473.,  1070., 1799., 1985., 1482., 823.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,  3596.,  4796.,  5996.,  7196.,  6344.,  6612.,  13062.,
      15726., 18390., 21054., 17220., 16116., 29046., 31710., 34374.,
      37038., 29028., 25620., 45030., 47694., 50358., 53022., 40836.,
      30664., 51260., 53612., 55964., 58316., 43112.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,  394.,   706.,   828.,   614.,   340.,   1288.,
      2972.,  4172., 3944.,  2596.,  1698.,  4980.,  10038., 12702.,
      10884., 6714., 3972.,  9448.,  16556., 18908., 14664., 8404.,
      3662.,  8300., 13978., 15442., 11548., 6422.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84.,   140.,  200.,  296.,  272.,  380.,  344.,  464.,  416.,  548.,
      372.,  468.,  378.,  516.,  759.,  984.,  921.,  1164., 1083., 1344.,
      1245., 1524., 1026., 1224., 954.,  1164., 1731., 2064., 1893., 2244.,
      2055., 2424., 2217., 2604., 1746., 2016., 1530., 1812., 2703., 3144.,
      2865., 3324., 3027., 3504., 3189., 3684., 2466., 2808., 1860., 2084.,
      3116., 3464., 3260., 3620., 3404., 3776., 3548., 3932., 2628., 2892.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,    6.,    16.,   19.,  40.,   37.,  64.,  46.,  68.,
      35.,  48.,   16.,   36.,   68.,  116.,  164., 248., 236., 332.,
      228., 300.,  152.,  192.,  93.,  144.,  282., 396., 579., 768.,
      741., 948.,  642.,  792.,  399., 480.,  236., 284., 564., 668.,
      992., 1160., 1136., 1316., 884., 1012., 508., 576., 221., 252.,
      502., 568.,  847.,  952.,  937., 1048., 702., 780., 391., 432.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      572.,   1004.,  1426.,  2170.,  1978.,  2818.,  2530.,  3466.,  3082.,
      4114.,  2796.,  3548.,  2766.,  3846.,  5649.,  7413.,  6909.,  8817.,
      8169.,  10221., 9429.,  11625., 7830.,  9390.,  7230.,  8886.,  13209.,
      15837., 14469., 17241., 15729., 18645., 16989., 20049., 13446., 15582.,
      11694., 13926., 20769., 24261., 22029., 25665., 23289., 27069., 24549.,
      28473., 19062., 21774., 14444., 16220., 24250., 27010., 25378., 28234.,
      26506., 29458., 27634., 30682., 20508., 22604.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    25.,   34.,   106.,   119.,  275.,  251.,  455.,  330.,  498.,
      257.,  357.,  94.,   246.,   460.,  828.,  1162., 1810., 1714., 2458.,
      1692., 2252., 1142., 1454.,  651.,  1047., 2046., 2934., 4281., 5757.,
      5541., 7161., 4854., 6030.,  3039., 3675., 1798., 2174., 4316., 5132.,
      7618., 8938., 8746., 10162., 6828., 7836., 3934., 4470., 1709., 1953.,
      3890., 4410., 6575., 7403.,  7283., 8159., 5466., 6082., 3049., 3373.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4184.,   7576.,   10724.,  16580.,  15044.,  21668.,  19364.,  26756.,
      23684.,  31844.,  21656.,  27608.,  21108.,  29652.,  43518.,  57486.,
      53454.,  68574.,  63390.,  79662.,  73326.,  90750.,  61140.,  73524.,
      56244.,  69396.,  103134., 124014., 113070., 135102., 123006., 146190.,
      132942., 157278., 105492., 122484., 91380.,  109140., 162750., 190542.,
      172686., 201630., 182622., 212718., 192558., 223806., 149844., 171444.,
      113816., 127960., 191300., 213284., 200228., 222980., 209156., 232676.,
      218084., 242372., 162008., 178712.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   220.,   764.,   826.,   2026.,  1834.,  3418.,  2492.,
      3804.,  1966.,  2750.,  620.,   1804.,  3352.,  6232.,  8708.,  13796.,
      13028., 18884., 13016., 17432., 8844.,  11308., 4842.,  7962.,  15540.,
      22548., 32862., 44526., 42798., 55614., 37716., 47028., 23706., 28746.,
      14028., 17004., 33752., 40216., 59684., 70148., 68612., 79844., 53656.,
      61656., 30956., 35212., 13438., 15374., 30620., 34748., 51802., 58378.,
      57418., 64378., 43132., 48028., 24078., 26654.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236.,   336.,   444.,   560.,   626.,   800.,   986.,   1184.,  890.,
      1088.,  1298.,  1520.,  1154.,  1376.,  1610.,  1856.,  1418.,  1664.,
      1922.,  2192.,  1308.,  1488.,  1676.,  1872.,  1254.,  1512.,  1782.,
      2064.,  2613.,  3036.,  3477.,  3936.,  3225.,  3684.,  4161.,  4656.,
      3837.,  4332.,  4845.,  5376.,  4449.,  4980.,  5529.,  6096.,  3726.,
      4104.,  4494.,  4896.,  3414.,  3816.,  4230.,  4656.,  6285.,  6924.,
      7581.,  8256.,  6897.,  7572.,  8265.,  8976.,  7509.,  8220.,  8949.,
      9696.,  8121.,  8868.,  9633.,  10416., 6462.,  6984.,  7518.,  8064.,
      5574.,  6120.,  6678.,  7248.,  9957.,  10812., 11685., 12576., 10569.,
      11460., 12369., 13296., 11181., 12108., 13053., 14016., 11793., 12756.,
      13737., 14736., 9198.,  9864.,  10542., 11232., 7004.,  7440.,  7884.,
      8336.,  11786., 12464., 13154., 13856., 12338., 13040., 13754., 14480.,
      12890., 13616., 14354., 15104., 13442., 14192., 14954., 15728., 9996.,
      10512., 11036., 11568.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   43.,   76.,
      115.,  160.,  103.,  148.,  199.,  256.,  146.,  184.,  226.,  272.,
      117.,  140.,  165.,  192.,  30.,   64.,   102.,  144.,  188.,  272.,
      364.,  464.,  506.,  656.,  818.,  992.,  770.,  944.,  1130., 1328.,
      780.,  912.,  1052., 1200., 534.,  608.,  686.,  768.,  279.,  372.,
      471.,  576.,  918.,  1128., 1350., 1584., 1965., 2316., 2685., 3072.,
      2577., 2964., 3369., 3792., 2286., 2568., 2862., 3168., 1443., 1596.,
      1755., 1920., 854.,  944.,  1038., 1136., 2060., 2256., 2460., 2672.,
      3650., 3968., 4298., 4640., 4202., 4544., 4898., 5264., 3292., 3536.,
      3788., 4048., 1902., 2032., 2166., 2304., 825.,  884.,  945.,  1008.,
      1882., 2008., 2138., 2272., 3187., 3388., 3595., 3808., 3535., 3748.,
      3967., 4192., 2658., 2808., 2962., 3120., 1485., 1564., 1645., 1728.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1700.,   2484.,   3332.,   4244.,   4678.,   6046.,   7510.,   9070.,
      6742.,   8302.,   9958.,   11710.,  8806.,   10558.,  12406.,  14350.,
      10870.,  12814.,  14854.,  16990.,  10116.,  11540.,  13028.,  14580.,
      9534.,   11574.,  13710.,  15942.,  20085.,  23433.,  26925.,  30561.,
      24909.,  28545.,  32325.,  36249.,  29733.,  33657.,  37725.,  41937.,
      34557.,  38769.,  43125.,  47625.,  29070.,  32070.,  35166.,  38358.,
      26526.,  29718.,  33006.,  36390.,  49029.,  54105.,  59325.,  64689.,
      53853.,  59217.,  64725.,  70377.,  58677.,  64329.,  70125.,  76065.,
      63501.,  69441.,  75525.,  81753.,  50670.,  54822.,  59070.,  63414.,
      43518.,  47862.,  52302.,  56838.,  77973.,  84777.,  91725.,  98817.,
      82797.,  89889.,  97125.,  104505., 87621.,  95001.,  102525., 110193.,
      92445.,  100113., 107925., 115881., 72270.,  77574.,  82974.,  88470.,
      55172.,  58644.,  62180.,  65780.,  92950.,  98350.,  103846., 109438.,
      97318.,  102910., 108598., 114382., 101686., 107470., 113350., 119326.,
      106054., 112030., 118102., 124270., 78948.,  83060.,  87236.,  91476.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   287.,
      539.,   839.,   1187.,  743.,   1091.,  1487.,  1931.,  1098.,  1394.,
      1722.,  2082.,  893.,   1073.,  1269.,  1481.,  178.,   442.,   738.,
      1066.,  1348.,  2004.,  2724.,  3508.,  3766.,  4942.,  6214.,  7582.,
      5830.,  7198.,  8662.,  10222., 5988.,  7028.,  8132.,  9300.,  4130.,
      4714.,  5330.,  5978.,  2055.,  2787.,  3567.,  4395.,  6942.,  8598.,
      10350., 12198., 15045., 17817., 20733., 23793., 19869., 22929., 26133.,
      29481., 17742., 19974., 22302., 24726., 11247., 12459., 13719., 15027.,
      6658.,  7370.,  8114.,  8890.,  16100., 17652., 19268., 20948., 28582.,
      31102., 33718., 36430., 32950., 35662., 38470., 41374., 25860., 27796.,
      29796., 31860., 14962., 15994., 17058., 18154., 6485.,  6953.,  7437.,
      7937.,  14810., 15810., 16842., 17906., 25103., 26699., 28343., 30035.,
      27863., 29555., 31295., 33083., 20970., 22162., 23386., 24642., 11725.,
      12353., 12997., 13657.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12856.,  19064.,  25784.,  33016.,  36116.,  46964.,  58580.,  70964.,
      52436.,  64820.,  77972.,  91892.,  68756.,  82676.,  97364.,  112820.,
      85076.,  100532., 116756., 133748., 79544.,  90872.,  102712., 115064.,
      74292.,  90516.,  107508., 125268., 157422., 184062., 211854., 240798.,
      195726., 224670., 254766., 286014., 234030., 265278., 297678., 331230.,
      272334., 305886., 340590., 376446., 229620., 253524., 278196., 303636.,
      209076., 234516., 260724., 287700., 387246., 427710., 469326., 512094.,
      425550., 468318., 512238., 557310., 463854., 508926., 555150., 602526.,
      502158., 549534., 598062., 647742., 401268., 434388., 468276., 502932.,
      343860., 378516., 413940., 450132., 617070., 671358., 726798., 783390.,
      655374., 711966., 769710., 828606., 693678., 752574., 812622., 873822.,
      731982., 793182., 855534., 919038., 572916., 615252., 658356., 702228.,
      437944., 465656., 493880., 522616., 738260., 781364., 825236., 869876.,
      773012., 817652., 863060., 909236., 807764., 853940., 900884., 948596.,
      842516., 890228., 938708., 987956., 627512., 660344., 693688., 727544.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      2074.,   4042.,   6394.,   9130.,   5626.,   8362.,   11482.,  14986.,
      8508.,   10844.,  13436.,  16284.,  6974.,   8398.,   9950.,   11630.,
      1180.,   3260.,   5596.,   8188.,   10168.,  15352.,  21048.,  27256.,
      29012.,  38324.,  48404.,  59252.,  45332.,  56180.,  67796.,  80180.,
      46904.,  55160.,  63928.,  73208.,  32476.,  37116.,  42012.,  47164.,
      15738.,  21546.,  27738.,  34314.,  53940.,  67092.,  81012.,  95700.,
      117678., 139710., 162894., 187230., 155982., 180318., 205806., 232446.,
      139764., 157524., 176052., 195348., 88794.,  98442.,  108474., 118890.,
      52572.,  58236.,  64156.,  70332.,  127288., 139640., 152504., 165880.,
      226196., 246260., 267092., 288692., 260948., 282548., 304916., 328052.,
      204984., 220408., 236344., 252792., 118684., 126908., 135388., 144124.,
      51422.,  55150.,  59006.,  62990.,  117500., 125468., 133692., 142172.,
      199258., 211978., 225082., 238570., 221242., 234730., 248602., 262858.,
      166588., 176092., 185852., 195868., 93182.,  98190.,  103326., 108590.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  62.,  83.,  75.,  99.,  192., 237., 198., 207., 372., 417., 330.,
      315., 552., 597., 462., 423., 732., 777., 594., 455., 758., 797., 589.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   7.,   6.,  7.,  23.,  33.,  24.,  24., 69.,  90.,  60.,
      48., 123., 156., 96., 63., 149., 175., 102., 49., 112., 127., 72.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,  412.,  568.,  528.,  678.,  1347., 1689., 1434.,
      1494., 2715., 3057., 2442., 2310., 4083., 4425., 3450.,
      3126., 5451., 5793., 4458., 3440., 5752., 6052., 4488.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5.,    22.,  42.,   39.,  40.,  144.,
                                         216.,  164., 153.,  462., 618., 423.,
                                         333.,  870., 1122., 699., 460., 1096.,
                                         1296., 760., 365.,  838., 954., 543.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,  4172.,  3944.,  4980.,  10038., 12702., 10884.,
      11316., 20694., 23358., 18756., 17652., 31350., 34014., 26628.,
      23988., 42006., 44670., 34500., 26728., 44780., 47132., 35016.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,  284.,  278.,  260.,  1000., 1544., 1204.,
      1074., 3348., 4548., 3162., 2466., 6516., 8484., 5322.,
      3508., 8392., 9960., 5860., 2814., 6476., 7388., 4214.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68.,   116.,  164.,  248.,  236.,  332.,  228.,  300.,  282.,  396.,
      579.,  768.,  741.,  948.,  642.,  792.,  666.,  828.,  1227., 1488.,
      1389., 1668., 1122., 1320., 1050., 1260., 1875., 2208., 2037., 2388.,
      1602., 1848., 1434., 1692., 2523., 2928., 2685., 3108., 2082., 2376.,
      1620., 1820., 2720., 3032., 2864., 3188., 2132., 2356.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   6.,   16.,  14.,  28.,  15.,  24.,  12.,  28.,  52.,  92.,
      84.,  132., 68.,  96.,  57.,  96.,  186., 276., 258., 360., 183., 240.,
      141., 192., 378., 492., 498., 624., 315., 384., 208., 252., 500., 596.,
      596., 700., 352., 408., 169., 196., 390., 448., 446., 508., 255., 288.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      460.,   828.,   1162.,  1810.,  1714.,  2458.,  1692.,  2252.,
      2046.,  2934.,  4281.,  5757.,  5541.,  7161.,  4854.,  6030.,
      5022.,  6294.,  9321.,  11373., 10581., 12777., 8598.,  10158.,
      7998.,  9654.,  14361., 16989., 15621., 18393., 12342., 14286.,
      10974., 13014., 19401., 22605., 20661., 24009., 16086., 18414.,
      12572., 14156., 21154., 23626., 22282., 24850., 16620., 18396.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    25.,   34.,   106.,  90.,   194.,  105.,  173.,  70.,   190.,
      348.,  652.,  588.,  956.,  494.,  710.,  387.,  687.,  1326., 2022.,
      1878., 2670., 1359., 1803., 1035., 1431., 2814., 3702., 3750., 4734.,
      2391., 2931., 1582., 1926., 3820., 4572., 4572., 5388., 2710., 3150.,
      1301., 1513., 3010., 3466., 3450., 3938., 1977., 2237.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3352.,  6232.,   8708.,   13796.,  13028.,  18884.,  13016.,  17432.,
      15540., 22548.,  32862.,  44526.,  42798.,  55614.,  37716.,  47028.,
      38964., 49044.,  72606.,  88878.,  82542.,  99966.,  67284.,  79668.,
      62388., 75540.,  112350., 133230., 122286., 144318., 96852.,  112308.,
      85812., 102036., 152094., 177582., 162030., 188670., 126420., 144948.,
      99032., 111640., 166820., 186500., 175748., 196196., 131224., 145368.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   220.,   764.,   636.,   1436.,  782.,   1310.,
      460.,   1388.,  2520.,  4888.,  4376.,  7256.,  3756.,  5452.,
      2826.,  5178.,  9972.,  15444., 14292., 20532., 10458., 13962.,
      7914.,  11034., 21684., 28692., 29076., 36852., 18618., 22890.,
      12332., 15052., 29848., 35800., 35800., 42264., 21260., 24748.,
      10206., 11886., 23644., 27260., 27132., 31004., 15566., 17630.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      188.,   272.,   364.,   464.,   506.,   656.,   818.,   992.,   770.,
      944.,   1130.,  1328.,  780.,   912.,   1052.,  1200.,  918.,   1128.,
      1350.,  1584.,  1965.,  2316.,  2685.,  3072.,  2577.,  2964.,  3369.,
      3792.,  2286.,  2568.,  2862.,  3168.,  2358.,  2664.,  2982.,  3312.,
      4413.,  4908.,  5421.,  5952.,  5025.,  5556.,  6105.,  6672.,  4110.,
      4488.,  4878.,  5280.,  3798.,  4200.,  4614.,  5040.,  6861.,  7500.,
      8157.,  8832.,  7473.,  8148.,  8841.,  9552.,  5934.,  6408.,  6894.,
      7392.,  5238.,  5736.,  6246.,  6768.,  9309.,  10092., 10893., 11712.,
      9921.,  10740., 11577., 12432., 7758.,  8328.,  8910.,  9504.,  6092.,
      6480.,  6876.,  7280.,  10274., 10880., 11498., 12128., 10826., 11456.,
      12098., 12752., 8092.,  8528.,  8972.,  9424.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   34.,   56.,
      82.,   112.,  45.,   60.,   77.,   96.,   22.,   48.,   78.,   112.,
      140.,  208.,  284.,  368.,  252.,  336.,  428.,  528.,  222.,  272.,
      326.,  384.,  159.,  228.,  303.,  384.,  582.,  744.,  918.,  1104.,
      846.,  1032., 1230., 1440., 627.,  732.,  843.,  960.,  471.,  564.,
      663.,  768.,  1302., 1512., 1734., 1968., 1758., 1992., 2238., 2496.,
      1131., 1260., 1395., 1536., 750.,  832.,  918.,  1008., 1820., 2000.,
      2188., 2384., 2188., 2384., 2588., 2800., 1302., 1408., 1518., 1632.,
      625.,  676.,  729.,  784.,  1450., 1560., 1674., 1792., 1666., 1784.,
      1906., 2032., 957.,  1020., 1085., 1152.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1348.,  2004.,   2724.,  3508.,  3766.,  4942.,  6214.,  7582.,  5830.,
      7198.,  8662.,   10222., 5988.,  7028.,  8132.,  9300.,  6942.,  8598.,
      10350., 12198.,  15045., 17817., 20733., 23793., 19869., 22929., 26133.,
      29481., 17742.,  19974., 22302., 24726., 18270., 20694., 23214., 25830.,
      34341., 38265.,  42333., 46545., 39165., 43377., 47733., 52233., 32142.,
      35142., 38238.,  41430., 29598., 32790., 36078., 39462., 53637., 58713.,
      63933., 69297.,  58461., 63825., 69333., 74985., 46542., 50310., 54174.,
      58134., 40926.,  44886., 48942., 53094., 72933., 79161., 85533., 92049.,
      77757., 84273.,  90933., 97737., 60942., 65478., 70110., 74838., 47972.,
      51060., 54212.,  57428., 80998., 85822., 90742., 95758., 85366., 90382.,
      95494., 100702., 63876., 67348., 70884., 74484.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   234.,
      402.,   602.,   834.,   333.,   449.,   581.,   729.,   130.,   330.,
      562.,   826.,   996.,   1524.,  2116.,  2772.,  1860.,  2516.,  3236.,
      4020.,  1682.,  2074.,  2498.,  2954.,  1143.,  1683.,  2271.,  2907.,
      4350.,  5622.,  6990.,  8454.,  6414.,  7878.,  9438.,  11094., 4815.,
      5643.,  6519.,  7443.,  3591.,  4323.,  5103.,  5931.,  10014., 11670.,
      13422., 15270., 13614., 15462., 17406., 19446., 8799.,  9819.,  10887.,
      12003., 5842.,  6490.,  7170.,  7882.,  14212., 15636., 17124., 18676.,
      17124., 18676., 20292., 21972., 10210., 11050., 11922., 12826., 4901.,
      5305.,  5725.,  6161.,  11386., 12258., 13162., 14098., 13098., 14034.,
      15002., 16002., 7533.,  8033.,  8549.,  9081.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10168.,  15352.,  21048.,  27256.,  29012.,  38324.,  48404.,  59252.,
      45332.,  56180.,  67796.,  80180.,  46904.,  55160.,  63928.,  73208.,
      53940.,  67092.,  81012.,  95700.,  117678., 139710., 162894., 187230.,
      155982., 180318., 205806., 232446., 139764., 157524., 176052., 195348.,
      143796., 163092., 183156., 203988., 270894., 302142., 334542., 368094.,
      309198., 342750., 377454., 413310., 254196., 278100., 302772., 328212.,
      233652., 259092., 285300., 312276., 424110., 464574., 506190., 548958.,
      462414., 505182., 549102., 594174., 368628., 398676., 429492., 461076.,
      323508., 355092., 387444., 420564., 577326., 627006., 677838., 729822.,
      615630., 667614., 720750., 775038., 483060., 519252., 556212., 593940.,
      380728., 405368., 430520., 456184., 643220., 681716., 720980., 761012.,
      677972., 718004., 758804., 800372., 507576., 535288., 563512., 592248.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      1724.,   3036.,   4604.,   6428.,   2558.,   3470.,   4510.,   5678.,
      860.,    2428.,   4252.,   6332.,   7480.,   11640.,  16312.,  21496.,
      14264.,  19448.,  25144.,  31352.,  13084.,  16188.,  19548.,  23164.,
      8634.,   12906.,  17562.,  22602.,  33588.,  43668.,  54516.,  66132.,
      49908.,  61524.,  73908.,  87060.,  37722.,  44298.,  51258.,  58602.,
      28026.,  33834.,  40026.,  46602.,  78516.,  91668.,  105588., 120276.,
      107124., 121812., 137268., 153492., 69402.,  77514.,  86010.,  94890.,
      46108.,  51260.,  56668.,  62332.,  112312., 123640., 135480., 147832.,
      135480., 147832., 160696., 174072., 80860.,  87548.,  94492.,  101692.,
      38814.,  42030.,  45374.,  48846.,  90236.,  97180.,  104380., 111836.,
      103868., 111324., 119036., 127004., 59774.,  63758.,  67870.,  72110.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,  68.,  89.,  110., 96.,  114., 219., 264., 309.,  252.,
      249., 444., 489., 534., 417., 384., 669., 714., 759.,  582.,
      519., 894., 939., 984., 747., 560., 929., 968., 1007., 740.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   10.,  12.,  9.,   8.,  26.,  56.,  54.,  36.,
      30., 84.,  165., 144., 90.,  66., 165., 300., 243., 144.,
      89., 206., 353., 270., 153., 70., 157., 262., 195., 108.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,  454.,  610.,  766.,  684.,  786.,  1545., 1887., 2229., 1842.,
      1806., 3255., 3597., 3939., 3102., 2826., 4965., 5307., 5649., 4362.,
      3846., 6675., 7017., 7359., 5622., 4244., 7066., 7366., 7666., 5652.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   22.,   59.,   78.,   61.,   46.,  164.,  370.,  372.,  254.,
      195., 570.,  1149., 1026., 651.,  465., 1182., 2175., 1782., 1065.,
      658., 1532., 2638., 2028., 1154., 527., 1186., 1985., 1482., 823.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,  3284.,  4484.,  5684.,  5144.,  5796.,  11550., 14214.,
      16878., 14052., 13716., 24870., 27534., 30198., 23892., 21636.,
      38190., 40854., 43518., 33732., 29556., 51510., 54174., 56838.,
      43572., 33016., 55076., 57428., 59780., 44152.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,   394.,   556.,   446.,   300.,   1144.,  2660.,
      2744., 1900.,  1386.,  4164.,  8526.,  7716.,  4938.,  3474.,
      8916., 16518., 13620., 8178.,  5052.,  11800., 20372., 15704.,
      8956., 4086.,  9212.,  15442., 11548., 6422.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76.,   128.,  182.,  272.,  254.,  356.,  326.,  440.,  300.,  384.,
      330.,  456.,  669.,  876.,  831.,  1056., 993.,  1236., 834.,  1008.,
      810.,  996.,  1479., 1776., 1641., 1956., 1803., 2136., 1434., 1668.,
      1290., 1536., 2289., 2676., 2451., 2856., 2613., 3036., 2034., 2328.,
      1770., 2076., 3099., 3576., 3261., 3756., 3423., 3936., 2634., 2988.,
      2004., 2240., 3350., 3716., 3494., 3872., 3638., 4028., 2692., 2960.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   6.,   16.,  19.,   40.,   30.,  48.,   25.,  36.,
      14.,  32.,  60.,  104., 146.,  224.,  156., 216.,  110., 144.,
      75.,  120., 234., 336., 489.,  660.,  450., 576.,  291., 360.,
      201., 264., 522., 660., 975.,  1200., 810., 972.,  489., 576.,
      302., 356., 708., 824., 1226., 1412., 948., 1080., 542., 612.,
      247., 280., 558., 628., 937.,  1048., 702., 780.,  391., 432.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      516.,   916.,   1294.,  1990.,  1846.,  2638.,  2398.,  3286.,  2244.,
      2900.,  2406.,  3390.,  4965.,  6585.,  6225.,  7989.,  7485.,  9393.,
      6342.,  7710.,  6126.,  7590.,  11265., 13605., 12525., 15009., 13785.,
      16413., 11022., 12870., 9846.,  11790., 17565., 20625., 18825., 22029.,
      20085., 23433., 15702., 18030., 13566., 15990., 23865., 27645., 25125.,
      29049., 26385., 30453., 20382., 23190., 15572., 17444., 26086., 28990.,
      27214., 30214., 28342., 31438., 21012., 23140.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    25.,   34.,   106.,  119.,  275.,   210.,  346.,  181.,  265.,
      82.,   218.,  404.,  740.,  1030., 1630.,  1140., 1604., 818.,  1082.,
      519.,  867.,  1686., 2478., 3597., 4929.,  3366., 4350., 2199., 2739.,
      1491., 1983., 3918., 4998., 7377., 9141.,  6174., 7446., 3747., 4431.,
      2314., 2738., 5444., 6356., 9454., 10918., 7332., 8372., 4202., 4754.,
      1913., 2173., 4330., 4882., 7283., 8159.,  5466., 6082., 3049., 3373.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3768.,   6904.,   9716.,   15188.,  14036.,  20276.,  18356.,  25364.,
      17336.,  22520.,  18324.,  26100.,  38190.,  51006.,  48126.,  62094.,
      58062.,  73182.,  49428.,  60276.,  47604.,  59220.,  87870.,  106446.,
      97806.,  117534., 107742., 128622., 86388.,  101076., 76884.,  92340.,
      137550., 161886., 147486., 172974., 157422., 184062., 123348., 141876.,
      106164., 125460., 187230., 217326., 197166., 228414., 207102., 239502.,
      160308., 182676., 122744., 137656., 205844., 228980., 214772., 238676.,
      223700., 248372., 166008., 182968.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   220.,   764.,   826.,   2026.,  1564.,  2620.,  1374.,
      2030.,  540.,   1596.,  2936.,  5560.,  7700.,  12404., 8696.,  12344.,
      6300.,  8380.,  3834.,  6570.,  12756., 18996., 27534., 38046., 26004.,
      33780., 17082., 21354., 11466., 15354., 30324., 38868., 57342., 71310.,
      48180., 58260., 29322., 34746., 18108., 21468., 42680., 49912., 74228.,
      85844., 57656., 65912., 33084., 37468., 15054., 17118., 34108., 38492.,
      57418., 64378., 43132., 48028., 24078., 26654.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      212.,   304.,   404.,   512.,   566.,   728.,   902.,   1088.,  830.,
      1016.,  1214.,  1424.,  1094.,  1304.,  1526.,  1760.,  1044.,  1200.,
      1364.,  1536.,  1086.,  1320.,  1566.,  1824.,  2289.,  2676.,  3081.,
      3504.,  2901.,  3324.,  3765.,  4224.,  3513.,  3972.,  4449.,  4944.,
      3006.,  3336.,  3678.,  4032.,  2886.,  3240.,  3606.,  3984.,  5349.,
      5916.,  6501.,  7104.,  5961.,  6564.,  7185.,  7824.,  6573.,  7212.,
      7869.,  8544.,  5286.,  5736.,  6198.,  6672.,  4686.,  5160.,  5646.,
      6144.,  8409.,  9156.,  9921.,  10704., 9021.,  9804.,  10605., 11424.,
      9633.,  10452., 11289., 12144., 7566.,  8136.,  8718.,  9312.,  6486.,
      7080.,  7686.,  8304.,  11469., 12396., 13341., 14304., 12081., 13044.,
      14025., 15024., 12693., 13692., 14709., 15744., 9846.,  10536., 11238.,
      11952., 7556.,  8016.,  8484.,  8960.,  12686., 13400., 14126., 14864.,
      13238., 13976., 14726., 15488., 13790., 14552., 15326., 16112., 10244.,
      10768., 11300., 11840.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   43.,   76.,
      115.,  160.,  90.,   120.,  154.,  192.,  81.,   100.,  121.,  144.,
      26.,   56.,   90.,   128.,  164.,  240.,  324.,  416.,  446.,  584.,
      734.,  896.,  516.,  624.,  740.,  864.,  378.,  440.,  506.,  576.,
      219.,  300.,  387.,  480.,  750.,  936.,  1134., 1344., 1641., 1956.,
      2289., 2640., 1566., 1800., 2046., 2304., 1035., 1164., 1299., 1440.,
      687.,  804.,  927.,  1056., 1830., 2088., 2358., 2640., 3477., 3900.,
      4341., 4800., 2934., 3240., 3558., 3888., 1791., 1956., 2127., 2304.,
      1106., 1208., 1314., 1424., 2612., 2832., 3060., 3296., 4550., 4904.,
      5270., 5648., 3540., 3792., 4052., 4320., 2034., 2168., 2306., 2448.,
      925.,  988.,  1053., 1120., 2098., 2232., 2370., 2512., 3535., 3748.,
      3967., 4192., 2658., 2808., 2962., 3120., 1485., 1564., 1645., 1728.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1524.,   2244.,   3028.,   3876.,   4222.,   5494.,   6862.,   8326.,
      6286.,   7750.,   9310.,   10966.,  8350.,   10006.,  11758.,  13606.,
      8052.,   9284.,   10580.,  11940.,  8238.,   10086.,  12030.,  14070.,
      17565.,  20625.,  23829.,  27177.,  22389.,  25737.,  29229.,  32865.,
      27213.,  30849.,  34629.,  38553.,  23406.,  26022.,  28734.,  31542.,
      22398.,  25206.,  28110.,  31110.,  41685.,  46185.,  50829.,  55617.,
      46509.,  51297.,  56229.,  61305.,  51333.,  56409.,  61629.,  66993.,
      41406.,  44982.,  48654.,  52422.,  36558.,  40326.,  44190.,  48150.,
      65805.,  71745.,  77829.,  84057.,  70629.,  76857.,  83229.,  89745.,
      75453.,  81969.,  88629.,  95433.,  59406.,  63942.,  68574.,  73302.,
      50718.,  55446.,  60270.,  65190.,  89925.,  97305.,  104829., 112497.,
      94749.,  102417., 110229., 118185., 99573.,  107529., 115629., 123873.,
      77406.,  82902.,  88494.,  94182.,  59540.,  63204.,  66932.,  70724.,
      100078., 105766., 111550., 117430., 104446., 110326., 116302., 122374.,
      108814., 114886., 121054., 127318., 80916.,  85092.,  89332.,  93636.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   287.,
      539.,   839.,   1187.,  666.,   898.,   1162.,  1458.,  613.,   761.,
      925.,   1105.,  154.,   386.,   650.,   946.,   1172.,  1764.,  2420.,
      3140.,  3310.,  4390.,  5566.,  6838.,  3924.,  4772.,  5684.,  6660.,
      2906.,  3394.,  3914.,  4466.,  1599.,  2235.,  2919.,  3651.,  5646.,
      7110.,  8670.,  10326., 12525., 15009., 17637., 20409., 12078., 13926.,
      15870., 17910., 8031.,  9051.,  10119., 11235., 5271.,  6195.,  7167.,
      8187.,  14142., 16182., 18318., 20550., 26997., 30345., 33837., 37473.,
      22878., 25302., 27822., 30438., 14007., 15315., 16671., 18075., 8650.,
      9458.,  10298., 11170., 20468., 22212., 24020., 25892., 35710., 38518.,
      41422., 44422., 27828., 29828., 31892., 34020., 16010., 17074., 18170.,
      19298., 7277.,  7777.,  8293.,  8825.,  16522., 17586., 18682., 19810.,
      27863., 29555., 31295., 33083., 20970., 22162., 23386., 24642., 11725.,
      12353., 12997., 13657.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11512.,  17208.,  23416.,  30136.,   32564.,  42644.,  53492.,  65108.,
      48884.,  60500.,  72884.,  86036.,   65204.,  78356.,  92276.,  106964.,
      63224.,  73016.,  83320.,  94136.,   64116.,  78804.,  94260.,  110484.,
      137550., 161886., 187374., 214014.,  175854., 202494., 230286., 259230.,
      214158., 243102., 273198., 304446.,  184692., 205524., 227124., 249492.,
      176436., 198804., 221940., 245844.,  329070., 364926., 401934., 440094.,
      367374., 405534., 444846., 485310.,  405678., 446142., 487758., 530526.,
      327732., 356244., 385524., 415572.,  288756., 318804., 349620., 381204.,
      520590., 567966., 616494., 666174.,  558894., 608574., 659406., 711390.,
      597198., 649182., 702318., 756606.,  470772., 506964., 543924., 581652.,
      401076., 438804., 477300., 516564.,  712110., 771006., 831054., 892254.,
      750414., 811614., 873966., 937470.,  788718., 852222., 916878., 982686.,
      613812., 657684., 702324., 747732.,  472696., 501944., 531704., 561976.,
      794996., 840404., 886580., 933524.,  829748., 876692., 924404., 972884.,
      864500., 912980., 962228., 1012244., 643192., 676536., 710392., 744760.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      2074.,   4042.,   6394.,   9130.,   5116.,   6940.,   9020.,   11356.,
      4766.,   5934.,   7230.,   8654.,   1020.,   2844.,   4924.,   7260.,
      8824.,   13496.,  18680.,  24376.,  25460.,  34004.,  43316.,  53396.,
      30584.,  37304.,  44536.,  52280.,  22780.,  26652.,  30780.,  35164.,
      12186.,  17226.,  22650.,  28458.,  43764.,  55380.,  67764.,  80916.,
      97806.,  117534., 138414., 160446., 94836.,  109524., 124980., 141204.,
      63258.,  71370.,  79866.,  88746.,  41274.,  48618.,  56346.,  64458.,
      111156., 127380., 144372., 162132., 212718., 239358., 267150., 296094.,
      180660., 199956., 220020., 240852., 110778., 121194., 131994., 143178.,
      68412.,  74844.,  81532.,  88476.,  162040., 175928., 190328., 205240.,
      282932., 305300., 328436., 352340., 220664., 236600., 253048., 270008.,
      127036., 135516., 144252., 153244., 57726.,  61710.,  65822.,  70062.,
      131132., 139612., 148348., 157340., 221242., 234730., 248602., 262858.,
      166588., 176092., 185852., 195868., 93182.,  98190.,  103326., 108590.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,   74.,   95.,  116., 137.,  117.,  129.,  246.,  291.,
      336.,  381.,  306., 291., 516.,  561.,  606.,  651.,  504.,
      453.,  786.,  831., 876., 921.,  702.,  615.,  1056., 1101.,
      1146., 1191., 900., 665., 1100., 1139., 1178., 1217., 891.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  16.,  17.,  12.,  9.,  29.,  62.,  83.,  75.,  48.,
      36.,  99.,  192., 237., 198., 120., 84., 207., 372., 417., 330., 192.,
      115., 263., 446., 485., 365., 204., 91., 202., 334., 358., 263., 144.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,  496.,  652.,  808.,  964.,  840.,  894.,  1743., 2085.,
      2427., 2769., 2250., 2118., 3795., 4137., 4479., 4821., 3762.,
      3342., 5847., 6189., 6531., 6873., 5274., 4566., 7899., 8241.,
      8583., 8925., 6786., 5048., 8380., 8680., 8980., 9280., 6816.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   101.,  114.,  83.,   52.,   184.,  412.,
      568.,  528.,  344.,  237.,  678.,  1347., 1689., 1434., 879.,
      597.,  1494., 2715., 3057., 2442., 1431., 856.,  1968., 3352.,
      3652., 2760., 1548., 689.,  1534., 2543., 2729., 2010., 1103.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,  3596.,  4796.,  5996.,  7196.,  6344.,  6612.,  13062., 15726.,
      18390., 21054., 17220., 16116., 29046., 31710., 34374., 37038., 29028.,
      25620., 45030., 47694., 50358., 53022., 40836., 35124., 61014., 63678.,
      66342., 69006., 52644., 39304., 65372., 67724., 70076., 72428., 53288.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   706.,   828.,   614.,   340.,   1288.,  2972.,
      4172.,  3944.,  2596.,  1698.,  4980.,  10038., 12702., 10884., 6714.,
      4482.,  11316., 20694., 23358., 18756., 11034., 6596.,  15208., 25964.,
      28316., 21448., 12052., 5358.,  11948., 19834., 21298., 15708., 8630.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84.,   140.,  200.,  296.,  272.,  380.,  344.,  464.,  416.,
      548.,  372.,  468.,  378.,  516.,  759.,  984.,  921.,  1164.,
      1083., 1344., 1245., 1524., 1026., 1224., 954.,  1164., 1731.,
      2064., 1893., 2244., 2055., 2424., 2217., 2604., 1746., 2016.,
      1530., 1812., 2703., 3144., 2865., 3324., 3027., 3504., 3189.,
      3684., 2466., 2808., 2106., 2460., 3675., 4224., 3837., 4404.,
      3999., 4584., 4161., 4764., 3186., 3600., 2388., 2660., 3980.,
      4400., 4124., 4556., 4268., 4712., 4412., 4868., 3252., 3564.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    6.,    16.,   19.,  40.,  37.,  64.,   46.,   68.,   35.,
      48.,   16.,   36.,   68.,   116., 164., 248., 236.,  332.,  228.,  300.,
      152.,  192.,  93.,   144.,  282., 396., 579., 768.,  741.,  948.,  642.,
      792.,  399.,  480.,  261.,  336., 666., 828., 1227., 1488., 1389., 1668.,
      1122., 1320., 663.,  768.,  396., 460., 916., 1052., 1568., 1784., 1712.,
      1940., 1300., 1460., 732.,  816., 325., 364., 726.,  808.,  1207., 1336.,
      1297., 1432., 958.,  1052., 527., 576.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      572.,   1004.,  1426.,  2170.,  1978.,  2818.,  2530.,  3466.,  3082.,
      4114.,  2796.,  3548.,  2766.,  3846.,  5649.,  7413.,  6909.,  8817.,
      8169.,  10221., 9429.,  11625., 7830.,  9390.,  7230.,  8886.,  13209.,
      15837., 14469., 17241., 15729., 18645., 16989., 20049., 13446., 15582.,
      11694., 13926., 20769., 24261., 22029., 25665., 23289., 27069., 24549.,
      28473., 19062., 21774., 16158., 18966., 28329., 32685., 29589., 34089.,
      30849., 35493., 32109., 36897., 24678., 27966., 18572., 20732., 31018.,
      34354., 32146., 35578., 33274., 36802., 34402., 38026., 25404., 27884.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    34.,    106.,   119.,   275.,   251.,   455.,   330.,
      498.,   257.,   357.,   94.,    246.,   460.,   828.,   1162.,  1810.,
      1714.,  2458.,  1692.,  2252.,  1142.,  1454.,  651.,   1047.,  2046.,
      2934.,  4281.,  5757.,  5541.,  7161.,  4854.,  6030.,  3039.,  3675.,
      1947.,  2535.,  5022.,  6294.,  9321.,  11373., 10581., 12777., 8598.,
      10158., 5103.,  5931.,  3046.,  3550.,  7068.,  8140.,  12130., 13834.,
      13258., 15058., 10092., 11356., 5694.,  6358.,  2525.,  2833.,  5650.,
      6298.,  9407.,  10427., 10115., 11183., 7482.,  8226.,  4121.,  4509.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4184.,   7576.,   10724.,  16580.,  15044.,  21668.,  19364.,  26756.,
      23684.,  31844.,  21656.,  27608.,  21108.,  29652.,  43518.,  57486.,
      53454.,  68574.,  63390.,  79662.,  73326.,  90750.,  61140.,  73524.,
      56244.,  69396.,  103134., 124014., 113070., 135102., 123006., 146190.,
      132942., 157278., 105492., 122484., 91380.,  109140., 162750., 190542.,
      172686., 201630., 182622., 212718., 192558., 223806., 149844., 171444.,
      126516., 148884., 222366., 257070., 232302., 268158., 242238., 279246.,
      252174., 290334., 194196., 220404., 146456., 163672., 244868., 271460.,
      253796., 281156., 262724., 290852., 271652., 300548., 200792., 220568.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    220.,   764.,   826.,   2026.,  1834.,  3418.,  2492.,
      3804.,   1966.,   2750.,  620.,   1804.,  3352.,  6232.,  8708.,  13796.,
      13028.,  18884.,  13016., 17432., 8844.,  11308., 4842.,  7962.,  15540.,
      22548.,  32862.,  44526., 42798., 55614., 37716., 47028., 23706., 28746.,
      15018.,  19674.,  38964., 49044., 72606., 88878., 82542., 99966., 67284.,
      79668.,  40026.,  46602., 23884., 27884., 55512., 64024., 95396., 108932.,
      104324., 118628., 79512., 89560., 44908., 50188., 19902., 22350., 44572.,
      49724.,  74266.,  82378., 79882., 88378., 59132., 65052., 32590., 35678.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236.,   336.,   444.,   560.,   626.,   800.,   986.,   1184.,  890.,
      1088.,  1298.,  1520.,  1154.,  1376.,  1610.,  1856.,  1418.,  1664.,
      1922.,  2192.,  1308.,  1488.,  1676.,  1872.,  1254.,  1512.,  1782.,
      2064.,  2613.,  3036.,  3477.,  3936.,  3225.,  3684.,  4161.,  4656.,
      3837.,  4332.,  4845.,  5376.,  4449.,  4980.,  5529.,  6096.,  3726.,
      4104.,  4494.,  4896.,  3414.,  3816.,  4230.,  4656.,  6285.,  6924.,
      7581.,  8256.,  6897.,  7572.,  8265.,  8976.,  7509.,  8220.,  8949.,
      9696.,  8121.,  8868.,  9633.,  10416., 6462.,  6984.,  7518.,  8064.,
      5574.,  6120.,  6678.,  7248.,  9957.,  10812., 11685., 12576., 10569.,
      11460., 12369., 13296., 11181., 12108., 13053., 14016., 11793., 12756.,
      13737., 14736., 9198.,  9864.,  10542., 11232., 7734.,  8424.,  9126.,
      9840.,  13629., 14700., 15789., 16896., 14241., 15348., 16473., 17616.,
      14853., 15996., 17157., 18336., 15465., 16644., 17841., 19056., 11934.,
      12744., 13566., 14400., 9020.,  9552.,  10092., 10640., 15098., 15920.,
      16754., 17600., 15650., 16496., 17354., 18224., 16202., 17072., 17954.,
      18848., 16754., 17648., 18554., 19472., 12396., 13008., 13628., 14256.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   43.,   76.,
      115.,  160.,  103.,  148.,  199.,  256.,  146.,  184.,  226.,  272.,
      117.,  140.,  165.,  192.,  30.,   64.,   102.,  144.,  188.,  272.,
      364.,  464.,  506.,  656.,  818.,  992.,  770.,  944.,  1130., 1328.,
      780.,  912.,  1052., 1200., 534.,  608.,  686.,  768.,  279.,  372.,
      471.,  576.,  918.,  1128., 1350., 1584., 1965., 2316., 2685., 3072.,
      2577., 2964., 3369., 3792., 2286., 2568., 2862., 3168., 1443., 1596.,
      1755., 1920., 903.,  1044., 1191., 1344., 2358., 2664., 2982., 3312.,
      4413., 4908., 5421., 5952., 5025., 5556., 6105., 6672., 4110., 4488.,
      4878., 5280., 2451., 2652., 2859., 3072., 1462., 1584., 1710., 1840.,
      3404., 3664., 3932., 4208., 5858., 6272., 6698., 7136., 6410., 6848.,
      7298., 7760., 4892., 5200., 5516., 5840., 2766., 2928., 3094., 3264.,
      1225., 1300., 1377., 1456., 2746., 2904., 3066., 3232., 4579., 4828.,
      5083., 5344., 4927., 5188., 5455., 5728., 3650., 3832., 4018., 4208.,
      2013., 2108., 2205., 2304.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1700.,   2484.,   3332.,   4244.,   4678.,   6046.,   7510.,   9070.,
      6742.,   8302.,   9958.,   11710.,  8806.,   10558.,  12406.,  14350.,
      10870.,  12814.,  14854.,  16990.,  10116.,  11540.,  13028.,  14580.,
      9534.,   11574.,  13710.,  15942.,  20085.,  23433.,  26925.,  30561.,
      24909.,  28545.,  32325.,  36249.,  29733.,  33657.,  37725.,  41937.,
      34557.,  38769.,  43125.,  47625.,  29070.,  32070.,  35166.,  38358.,
      26526.,  29718.,  33006.,  36390.,  49029.,  54105.,  59325.,  64689.,
      53853.,  59217.,  64725.,  70377.,  58677.,  64329.,  70125.,  76065.,
      63501.,  69441.,  75525.,  81753.,  50670.,  54822.,  59070.,  63414.,
      43518.,  47862.,  52302.,  56838.,  77973.,  84777.,  91725.,  98817.,
      82797.,  89889.,  97125.,  104505., 87621.,  95001.,  102525., 110193.,
      92445.,  100113., 107925., 115881., 72270.,  77574.,  82974.,  88470.,
      60510.,  66006.,  71598.,  77286.,  106917., 115449., 124125., 132945.,
      111741., 120561., 129525., 138633., 116565., 125673., 134925., 144321.,
      121389., 130785., 140325., 150009., 93870.,  100326., 106878., 113526.,
      71108.,  75348.,  79652.,  84020.,  119158., 125710., 132358., 139102.,
      123526., 130270., 137110., 144046., 127894., 134830., 141862., 148990.,
      132262., 139390., 146614., 153934., 97956.,  102836., 107780., 112788.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   287.,
      539.,   839.,   1187.,  743.,   1091.,  1487.,  1931.,  1098.,  1394.,
      1722.,  2082.,  893.,   1073.,  1269.,  1481.,  178.,   442.,   738.,
      1066.,  1348.,  2004.,  2724.,  3508.,  3766.,  4942.,  6214.,  7582.,
      5830.,  7198.,  8662.,  10222., 5988.,  7028.,  8132.,  9300.,  4130.,
      4714.,  5330.,  5978.,  2055.,  2787.,  3567.,  4395.,  6942.,  8598.,
      10350., 12198., 15045., 17817., 20733., 23793., 19869., 22929., 26133.,
      29481., 17742., 19974., 22302., 24726., 11247., 12459., 13719., 15027.,
      6951.,  8067.,  9231.,  10443., 18270., 20694., 23214., 25830., 34341.,
      38265., 42333., 46545., 39165., 43377., 47733., 52233., 32142., 35142.,
      38238., 41430., 19215., 20811., 22455., 24147., 11458., 12426., 13426.,
      14458., 26724., 28788., 30916., 33108., 46054., 49342., 52726., 56206.,
      50422., 53902., 57478., 61150., 38532., 40980., 43492., 46068., 21810.,
      23098., 24418., 25770., 9653.,  10249., 10861., 11489., 21658., 22914.,
      24202., 25522., 36143., 38123., 40151., 42227., 38903., 40979., 43103.,
      45275., 28842., 30290., 31770., 33282., 15917., 16673., 17445., 18233.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12856.,   19064.,   25784.,   33016.,   36116.,   46964.,   58580.,
      70964.,   52436.,   64820.,   77972.,   91892.,   68756.,   82676.,
      97364.,   112820.,  85076.,   100532.,  116756.,  133748.,  79544.,
      90872.,   102712.,  115064.,  74292.,   90516.,   107508.,  125268.,
      157422.,  184062.,  211854.,  240798.,  195726.,  224670.,  254766.,
      286014.,  234030.,  265278.,  297678.,  331230.,  272334.,  305886.,
      340590.,  376446.,  229620.,  253524.,  278196.,  303636.,  209076.,
      234516.,  260724.,  287700.,  387246.,  427710.,  469326.,  512094.,
      425550.,  468318.,  512238.,  557310.,  463854.,  508926.,  555150.,
      602526.,  502158.,  549534.,  598062.,  647742.,  401268.,  434388.,
      468276.,  502932.,  343860.,  378516.,  413940.,  450132.,  617070.,
      671358.,  726798.,  783390.,  655374.,  711966.,  769710.,  828606.,
      693678.,  752574.,  812622.,  873822.,  731982.,  793182.,  855534.,
      919038.,  572916.,  615252.,  658356.,  702228.,  478644.,  522516.,
      567156.,  612564.,  846894.,  915006.,  984270.,  1054686., 885198.,
      955614.,  1027182., 1099902., 923502.,  996222.,  1070094., 1145118.,
      961806.,  1036830., 1113006., 1190334., 744564.,  796116.,  848436.,
      901524.,  564664.,  598520.,  632888.,  667768.,  946772.,  999092.,
      1052180., 1106036., 981524.,  1035380., 1090004., 1145396., 1016276.,
      1071668., 1127828., 1184756., 1051028., 1107956., 1165652., 1224116.,
      778808.,  817784.,  857272.,  897272.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      2074.,   4042.,   6394.,   9130.,   5626.,   8362.,   11482.,  14986.,
      8508.,   10844.,  13436.,  16284.,  6974.,   8398.,   9950.,   11630.,
      1180.,   3260.,   5596.,   8188.,   10168.,  15352.,  21048.,  27256.,
      29012.,  38324.,  48404.,  59252.,  45332.,  56180.,  67796.,  80180.,
      46904.,  55160.,  63928.,  73208.,  32476.,  37116.,  42012.,  47164.,
      15738.,  21546.,  27738.,  34314.,  53940.,  67092.,  81012.,  95700.,
      117678., 139710., 162894., 187230., 155982., 180318., 205806., 232446.,
      139764., 157524., 176052., 195348., 88794.,  98442.,  108474., 118890.,
      54522.,  63402.,  72666.,  82314.,  143796., 163092., 183156., 203988.,
      270894., 302142., 334542., 368094., 309198., 342750., 377454., 413310.,
      254196., 278100., 302772., 328212., 152154., 164874., 177978., 191466.,
      90716.,  98428.,  106396., 114620., 211768., 228216., 245176., 262648.,
      365204., 391412., 418388., 446132., 399956., 427700., 456212., 485492.,
      305848., 325368., 345400., 365944., 173212., 183484., 194012., 204796.,
      76638.,  81390.,  86270.,  91278.,  172028., 182044., 192316., 202844.,
      287194., 302986., 319162., 335722., 309178., 325738., 342682., 360010.,
      229308., 240860., 252668., 264732., 126590., 132622., 138782., 145070.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,   62.,   83.,   75.,   99.,   192.,  237.,  198.,  207.,  372.,
      417.,  330.,  263.,  446.,  485.,  365.,  221.,  398.,  419.,  331.,
      531.,  912.,  957.,  726.,  639.,  1092., 1137., 858.,  647.,  1070.,
      1109., 813.,  413.,  734.,  755.,  587.,  963.,  1632., 1677., 1254.,
      1071., 1812., 1857., 1386., 1031., 1694., 1733., 1261.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,  4.,   7.,   6.,   7.,   23.,  33.,  24.,  19., 53.,  63.,  42.,
      21., 52.,  59.,  36.,  5.,   16.,  27.,  18.,  27., 71.,  97.,  60.,
      63., 149., 175., 102., 49.,  112., 127., 72.,  9.,  28.,  47.,  30.,
      47., 119., 161., 96.,  107., 245., 287., 162., 77., 172., 195., 108.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,  412.,   568.,   528.,   678.,  1347.,  1689.,  1434.,
      1494., 2715.,  3057.,  2442.,  1968., 3352.,  3652.,  2760.,
      1592., 2908.,  3064.,  2448.,  3942., 6819.,  7161.,  5466.,
      4758., 8187.,  8529.,  6474.,  4912., 8152.,  8452.,  6216.,
      3000., 5404.,  5560.,  4368.,  7206., 12291., 12633., 9498.,
      8022., 13659., 14001., 10506., 7856., 12952., 13252., 9672.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,   22.,   42.,   39.,   40.,  144.,  216.,  164., 124.,  360.,
      432., 296.,  149.,  374.,  426., 263.,  29.,   102., 186.,  127.,
      184., 496.,  696.,  436.,  460., 1096., 1296., 760., 365.,  838.,
      954., 543.,  53.,   182.,  330., 215.,  328.,  848., 1176., 708.,
      796., 1832., 2160., 1224., 581., 1302., 1482., 823.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,   4172.,   3944.,  4980.,  10038.,  12702.,  10884.,
      11316., 20694.,  23358.,  18756., 15208., 25964.,  28316.,  21448.,
      12040., 22172.,  23372.,  18792., 30324., 52662.,  55326.,  42372.,
      36660., 63318.,  65982.,  50244., 38248., 63596.,  65948.,  48584.,
      22792., 41372.,  42572.,  33640., 55668., 95286.,  97950.,  73860.,
      62004., 105942., 108606., 81732., 61288., 101228., 103580., 75720.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,   140.,   284.,   278.,  260.,  1000.,  1544.,  1204., 884.,  2632.,
      3176., 2212.,  1118.,  2828., 3228., 2006.,  190.,   716.,  1372., 950.,
      1348., 3688.,  5256.,  3316., 3508., 8392.,  9960.,  5860., 2814., 6476.,
      7388., 4214.,  350.,   1292., 2460., 1622.,  2436.,  6376., 8968., 5428.,
      6132., 14152., 16744., 9508., 4510., 10124., 11548., 6422.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68.,   116.,  164.,  248.,  236.,  332.,  228.,  300.,  282.,  396.,
      579.,  768.,  741.,  948.,  642.,  792.,  666.,  828.,  1227., 1488.,
      1389., 1668., 1122., 1320., 916.,  1052., 1568., 1784., 1712., 1940.,
      1300., 1460., 708.,  884.,  1316., 1592., 1388., 1676., 1124., 1324.,
      1818., 2124., 3171., 3648., 3333., 3828., 2562., 2904., 2202., 2556.,
      3819., 4368., 3981., 4548., 3042., 3432., 2324., 2588., 3872., 4280.,
      4016., 4436., 2964., 3252., 1348., 1652., 2468., 2936., 2540., 3020.,
      2020., 2348., 3354., 3852., 5763., 6528., 5925., 6708., 4482., 5016.,
      3738., 4284., 6411., 7248., 6573., 7428., 4962., 5544., 3732., 4124.,
      6176., 6776., 6320., 6932., 4628., 5044.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    6.,   16.,  14.,  28.,  15.,  24.,  12.,  28.,  52.,  92.,
      84.,   132.,  68.,  96.,  48.,  76.,  148., 212., 180., 252., 128., 168.,
      65.,   84.,   166., 208., 190., 236., 119., 144., 9.,   20.,  38.,  64.,
      78.,   108.,  55.,  72.,  76.,  108., 212., 284., 308., 388., 196., 240.,
      208.,  252.,  500., 596., 596., 700., 352., 408., 169., 196., 390., 448.,
      446.,  508.,  255., 288., 17.,  36.,  70.,  112., 142., 188., 95.,  120.,
      140.,  188.,  372., 476., 532., 644., 324., 384., 368., 428., 852., 980.,
      1012., 1148., 576., 648., 273., 308., 614., 688., 702., 780., 391., 432.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      460.,   828.,   1162.,  1810.,  1714.,  2458.,  1692.,  2252.,  2046.,
      2934.,  4281.,  5757.,  5541.,  7161.,  4854.,  6030.,  5022.,  6294.,
      9321.,  11373., 10581., 12777., 8598.,  10158., 7068.,  8140.,  12130.,
      13834., 13258., 15058., 10092., 11356., 5324.,  6716.,  9994.,  12178.,
      10546., 12826., 8604.,  10188., 13950., 16374., 24441., 28221., 25701.,
      29625., 19830., 22542., 16926., 19734., 29481., 33837., 30741., 35241.,
      23574., 26670., 18076., 20172., 30178., 33418., 31306., 34642., 23148.,
      25436., 10188., 12604., 18826., 22546., 19378., 23194., 15516., 18124.,
      25854., 29814., 44601., 50685., 45861., 52089., 34806., 39054., 28830.,
      33174., 49641., 56301., 50901., 57705., 38550., 43182., 29084., 32204.,
      48226., 53002., 49354., 54226., 36204., 39516.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    25.,   34.,   106.,  90.,   194.,  105.,  173.,  70.,   190.,
      348.,  652.,  588.,  956.,  494.,  710.,  334.,  550.,  1068., 1564.,
      1308., 1868., 950.,  1262., 485.,  633.,  1250., 1578., 1434., 1794.,
      905.,  1101., 53.,   137.,  258.,  458.,  570.,  802.,  409.,  541.,
      550.,  798.,  1564., 2124., 2316., 2940., 1486., 1830., 1582., 1926.,
      3820., 4572., 4572., 5388., 2710., 3150., 1301., 1513., 3010., 3466.,
      3450., 3938., 1977., 2237., 101.,  249.,  482.,  810.,  1050., 1410.,
      713.,  909.,  1030., 1406., 2780., 3596., 4044., 4924., 2478., 2950.,
      2830., 3302., 6572., 7580., 7836., 8908., 4470., 5038., 2117., 2393.,
      4770., 5354., 5466., 6082., 3049., 3373.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3352.,   6232.,   8708.,   13796.,  13028.,  18884.,  13016.,  17432.,
      15540.,  22548.,  32862.,  44526.,  42798.,  55614.,  37716.,  47028.,
      38964.,  49044.,  72606.,  88878.,  82542.,  99966.,  67284.,  79668.,
      55512.,  64024.,  95396.,  108932., 104324., 118628., 79512.,  89560.,
      41240.,  52312.,  77828.,  95204.,  82148.,  100292., 67288.,  79896.,
      109236., 128532., 191838., 221934., 201774., 233022., 155988., 177588.,
      132660., 155028., 231582., 266286., 241518., 277374., 185556., 210228.,
      142552., 159256., 238244., 264068., 247172., 273764., 182936., 201176.,
      79128.,  98392.,  146948., 176612., 151268., 181700., 121560., 142360.,
      202932., 234516., 350814., 399342., 360750., 410430., 274260., 308148.,
      226356., 261012., 390558., 443694., 400494., 454782., 303828., 340788.,
      229592., 254488., 381092., 419204., 390020., 428900., 286360., 312792.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   220.,   764.,   636.,   1436.,  782.,   1310.,  460.,
      1388.,  2520.,  4888.,  4376.,  7256.,  3756.,  5452.,  2476.,  4172.,
      8088.,  11992., 9944.,  14360., 7308.,  9772.,  3742.,  4910.,  9692.,
      12284., 11132., 13980., 7054.,  8606.,  350.,   1006.,  1884.,  3452.,
      4348.,  6172.,  3150.,  4190.,  4172.,  6124.,  11992., 16408., 17944.,
      22872., 11564., 14284., 12332., 15052., 29848., 35800., 35800., 42264.,
      21260., 24748., 10206., 11886., 23644., 27260., 27132., 31004., 15566.,
      17630., 670.,   1838.,  3548.,  6140.,  8060.,  10908., 5518.,  7070.,
      7884.,  10860., 21464., 27928., 31512., 38488., 19372., 23116., 22188.,
      25932., 51608., 59608., 61656., 70168., 35212., 39724., 16670., 18862.,
      37596., 42236., 43132., 48028., 24078., 26654.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      188.,   272.,   364.,   464.,   506.,   656.,   818.,   992.,   770.,
      944.,   1130.,  1328.,  780.,   912.,   1052.,  1200.,  918.,   1128.,
      1350.,  1584.,  1965.,  2316.,  2685.,  3072.,  2577.,  2964.,  3369.,
      3792.,  2286.,  2568.,  2862.,  3168.,  2358.,  2664.,  2982.,  3312.,
      4413.,  4908.,  5421.,  5952.,  5025.,  5556.,  6105.,  6672.,  4110.,
      4488.,  4878.,  5280.,  3404.,  3664.,  3932.,  4208.,  5858.,  6272.,
      6698.,  7136.,  6410.,  6848.,  7298.,  7760.,  4892.,  5200.,  5516.,
      5840.,  2492.,  2832.,  3180.,  3536.,  4730.,  5264.,  5810.,  6368.,
      4994.,  5552.,  6122.,  6704.,  4108.,  4496.,  4892.,  5296.,  6678.,
      7272.,  7878.,  8496.,  11757., 12684., 13629., 14592., 12369., 13332.,
      14313., 15312., 9582.,  10248., 10926., 11616., 8118.,  8808.,  9510.,
      10224., 14205., 15276., 16365., 17472., 14817., 15924., 17049., 18192.,
      11406., 12168., 12942., 13728., 8780.,  9296.,  9820.,  10352., 14690.,
      15488., 16298., 17120., 15242., 16064., 16898., 17744., 11292., 11856.,
      12428., 13008., 4796.,  5392.,  5996.,  6608.,  8954.,  9872.,  10802.,
      11744., 9218.,  10160., 11114., 12080., 7436.,  8080.,  8732.,  9392.,
      12438., 13416., 14406., 15408., 21549., 23052., 24573., 26112., 22161.,
      23700., 25257., 26832., 16878., 17928., 18990., 20064., 13878., 14952.,
      16038., 17136., 23997., 25644., 27309., 28992., 24609., 26292., 27993.,
      29712., 18702., 19848., 21006., 22176., 14156., 14928., 15708., 16496.,
      23522., 24704., 25898., 27104., 24074., 25280., 26498., 27728., 17692.,
      18512., 19340., 20176.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   34.,   56.,
      82.,   112.,  45.,   60.,   77.,   96.,   22.,   48.,   78.,   112.,
      140.,  208.,  284.,  368.,  252.,  336.,  428.,  528.,  222.,  272.,
      326.,  384.,  142.,  192.,  246.,  304.,  476.,  592.,  716.,  848.,
      588.,  720.,  860.,  1008., 438.,  512.,  590.,  672.,  225.,  260.,
      297.,  336.,  586.,  664.,  746.,  832.,  674.,  760.,  850.,  944.,
      429.,  476.,  525.,  576.,  17.,   36.,   57.,   80.,   106.,  152.,
      202.,  256.,  258.,  312.,  370.,  432.,  189.,  220.,  253.,  288.,
      246.,  304.,  366.,  432.,  716.,  848.,  988.,  1136., 1084., 1232.,
      1388., 1552., 702.,  784.,  870.,  960.,  750.,  832.,  918.,  1008.,
      1820., 2000., 2188., 2384., 2188., 2384., 2588., 2800., 1302., 1408.,
      1518., 1632., 625.,  676.,  729.,  784.,  1450., 1560., 1674., 1792.,
      1666., 1784., 1906., 2032., 957.,  1020., 1085., 1152., 33.,   68.,
      105.,  144.,  202.,  280.,  362.,  448.,  482.,  568.,  658.,  752.,
      333.,  380.,  429.,  480.,  470.,  560.,  654.,  752.,  1292., 1488.,
      1692., 1904., 1916., 2128., 2348., 2576., 1182., 1296., 1414., 1536.,
      1358., 1472., 1590., 1712., 3164., 3408., 3660., 3920., 3788., 4048.,
      4316., 4592., 2166., 2304., 2446., 2592., 1025., 1092., 1161., 1232.,
      2314., 2456., 2602., 2752., 2658., 2808., 2962., 3120., 1485., 1564.,
      1645., 1728.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1348.,   2004.,   2724.,   3508.,   3766.,   4942.,   6214.,   7582.,
      5830.,   7198.,   8662.,   10222.,  5988.,   7028.,   8132.,   9300.,
      6942.,   8598.,   10350.,  12198.,  15045.,  17817.,  20733.,  23793.,
      19869.,  22929.,  26133.,  29481.,  17742.,  19974.,  22302.,  24726.,
      18270.,  20694.,  23214.,  25830.,  34341.,  38265.,  42333.,  46545.,
      39165.,  43377.,  47733.,  52233.,  32142.,  35142.,  38238.,  41430.,
      26724.,  28788.,  30916.,  33108.,  46054.,  49342.,  52726.,  56206.,
      50422.,  53902.,  57478.,  61150.,  38532.,  40980.,  43492.,  46068.,
      19268.,  21972.,  24740.,  27572.,  36790.,  41038.,  45382.,  49822.,
      38854.,  43294.,  47830.,  52462.,  32100.,  35188.,  38340.,  41556.,
      52254.,  56982.,  61806.,  66726.,  92229.,  99609.,  107133., 114801.,
      97053.,  104721., 112533., 120489., 75342.,  80646.,  86046.,  91542.,
      63582.,  69078.,  74670.,  80358.,  111525., 120057., 128733., 137553.,
      116349., 125169., 134133., 143241., 89742.,  95814.,  101982., 108246.,
      69220.,  73332.,  77508.,  81748.,  115942., 122302., 128758., 135310.,
      120310., 126862., 133510., 140254., 89220.,  93716.,  98276.,  102900.,
      37188.,  41940.,  46756.,  51636.,  69814.,  77134.,  84550.,  92062.,
      71878.,  79390.,  86998.,  94702.,  58212.,  63348.,  68548.,  73812.,
      97566.,  105366., 113262., 121254., 169413., 181401., 193533., 205809.,
      174237., 186513., 198933., 211497., 132942., 141318., 149790., 158358.,
      108894., 117462., 126126., 134886., 188709., 201849., 215133., 228561.,
      193533., 206961., 220533., 234249., 147342., 156486., 165726., 175062.,
      111716., 117876., 124100., 130388., 185830., 195262., 204790., 214414.,
      190198., 199822., 209542., 219358., 139908., 146452., 153060., 159732.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   234.,
      402.,   602.,   834.,   333.,   449.,   581.,   729.,   130.,   330.,
      562.,   826.,   996.,   1524.,  2116.,  2772.,  1860.,  2516.,  3236.,
      4020.,  1682.,  2074.,  2498.,  2954.,  1042.,  1434.,  1858.,  2314.,
      3588.,  4500.,  5476.,  6516.,  4452.,  5492.,  6596.,  7764.,  3362.,
      3946.,  4562.,  5210.,  1733.,  2009.,  2301.,  2609.,  4538.,  5154.,
      5802.,  6482.,  5226.,  5906.,  6618.,  7362.,  3341.,  3713.,  4101.,
      4505.,  101.,   249.,   413.,   593.,   762.,   1122.,  1514.,  1938.,
      1962.,  2386.,  2842.,  3330.,  1453.,  1697.,  1957.,  2233.,  1858.,
      2314.,  2802.,  3322.,  5476.,  6516.,  7620.,  8788.,  8388.,  9556.,
      10788., 12084., 5458.,  6106.,  6786.,  7498.,  5842.,  6490.,  7170.,
      7882.,  14212., 15636., 17124., 18676., 17124., 18676., 20292., 21972.,
      10210., 11050., 11922., 12826., 4901.,  5305.,  5725.,  6161.,  11386.,
      12258., 13162., 14098., 13098., 14034., 15002., 16002., 7533.,  8033.,
      8549.,  9081.,  197.,   473.,   765.,   1073.,  1466.,  2082.,  2730.,
      3410.,  3690.,  4370.,  5082.,  5826.,  2573.,  2945.,  3333.,  3737.,
      3586.,  4298.,  5042.,  5818.,  9956.,  11508., 13124., 14804., 14916.,
      16596., 18340., 20148., 9234.,  10138., 11074., 12042., 10642., 11546.,
      12482., 13450., 24836., 26772., 28772., 30836., 29796., 31860., 33988.,
      36180., 17058., 18154., 19282., 20442., 8069.,  8601.,  9149.,  9713.,
      18234., 19362., 20522., 21714., 20970., 22162., 23386., 24642., 11725.,
      12353., 12997., 13657.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10168.,   15352.,   21048.,   27256.,   29012.,   38324.,   48404.,
      59252.,   45332.,   56180.,   67796.,   80180.,   46904.,   55160.,
      63928.,   73208.,   53940.,   67092.,   81012.,   95700.,   117678.,
      139710.,  162894.,  187230.,  155982.,  180318.,  205806.,  232446.,
      139764.,  157524.,  176052.,  195348.,  143796.,  163092.,  183156.,
      203988.,  270894.,  302142.,  334542.,  368094.,  309198.,  342750.,
      377454.,  413310.,  254196.,  278100.,  302772.,  328212.,  211768.,
      228216.,  245176.,  262648.,  365204.,  391412.,  418388.,  446132.,
      399956.,  427700.,  456212.,  485492.,  305848.,  325368.,  345400.,
      365944.,  151480.,  173048.,  195128.,  217720.,  290132.,  324020.,
      358676.,  394100.,  306452.,  341876.,  378068.,  415028.,  253752.,
      278392.,  303544.,  329208.,  413364.,  451092.,  489588.,  528852.,
      730542.,  789438.,  849486.,  910686.,  768846.,  830046.,  892398.,
      955902.,  597492.,  639828.,  682932.,  726804.,  503220.,  547092.,
      591732.,  637140.,  883758.,  951870.,  1021134., 1091550., 922062.,
      992478.,  1064046., 1136766., 711924.,  760404.,  809652.,  859668.,
      549688.,  582520.,  615864.,  649720.,  921236.,  972020.,  1023572.,
      1075892., 955988.,  1008308., 1061396., 1115252., 709304.,  745208.,
      781624.,  818552.,  292792.,  330744.,  369208.,  408184.,  551252.,
      609716.,  668948.,  728948.,  567572.,  627572.,  688340.,  749876.,
      460600.,  501624.,  543160.,  585208.,  772788.,  835092.,  898164.,
      962004.,  1343406., 1439166., 1536078., 1634142., 1381710., 1479774.,
      1578990., 1679358., 1055220., 1122132., 1189812., 1258260., 862644.,
      931092.,  1000308., 1070292., 1496622., 1601598., 1707726., 1815006.,
      1534926., 1642206., 1750638., 1860222., 1169652., 1242708., 1316532.,
      1391124., 887608.,  936824.,  986552.,  1036792., 1477268., 1552628.,
      1628756., 1705652., 1512020., 1588916., 1666580., 1745012., 1112760.,
      1165048., 1217848., 1271160.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      1724.,   3036.,   4604.,   6428.,   2558.,   3470.,   4510.,   5678.,
      860.,    2428.,   4252.,   6332.,   7480.,   11640.,  16312.,  21496.,
      14264.,  19448.,  25144.,  31352.,  13084.,  16188.,  19548.,  23164.,
      7964.,   11068.,  14428.,  18044.,  27832.,  35064.,  42808.,  51064.,
      34616.,  42872.,  51640.,  60920.,  26332.,  30972.,  35868.,  41020.,
      13598.,  15790.,  18110.,  20558.,  35708.,  40604.,  45756.,  51164.,
      41148.,  46556.,  52220.,  58140.,  26366.,  29326.,  32414.,  35630.,
      670.,    1838.,   3134.,   4558.,   5756.,   8604.,   11708.,  15068.,
      15292.,  18652.,  22268.,  26140.,  11390.,  13326.,  15390.,  17582.,
      14428.,  18044.,  21916.,  26044.,  42808.,  51064.,  59832.,  69112.,
      65976.,  75256.,  85048.,  95352.,  43036.,  48188.,  53596.,  59260.,
      46108.,  51260.,  56668.,  62332.,  112312., 123640., 135480., 147832.,
      135480., 147832., 160696., 174072., 80860.,  87548.,  94492.,  101692.,
      38814.,  42030.,  45374.,  48846.,  90236.,  97180.,  104380., 111836.,
      103868., 111324., 119036., 127004., 59774.,  63758.,  67870.,  72110.,
      1310.,   3502.,   5822.,   8270.,   11132.,  16028.,  21180.,  26588.,
      28860.,  34268.,  39932.,  45852.,  20222.,  23182.,  26270.,  29486.,
      27996.,  33660.,  39580.,  45756.,  78136.,  90488.,  103352., 116728.,
      117688., 131064., 144952., 159352., 72988.,  80188.,  87644.,  95356.,
      84252.,  91452.,  98908.,  106620., 196792., 212216., 228152., 244600.,
      236344., 252792., 269752., 287224., 135388., 144124., 153116., 162364.,
      64030.,  68270.,  72638.,  77134.,  144764., 153756., 163004., 172508.,
      166588., 176092., 185852., 195868., 93182.,  98190.,  103326., 108590.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,   68.,   89.,   110.,  96.,   114.,  219.,  264.,  309.,  252.,
      249.,  444.,  489.,  534.,  417.,  320.,  539.,  578.,  617.,  460.,
      272.,  488.,  509.,  530.,  416.,  654.,  1119., 1164., 1209., 912.,
      789.,  1344., 1389., 1434., 1077., 800.,  1319., 1358., 1397., 1020.,
      512.,  908.,  929.,  950.,  736.,  1194., 2019., 2064., 2109., 1572.,
      1329., 2244., 2289., 2334., 1737., 1280., 2099., 2138., 2177., 1580.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  12.,  9.,   8.,   26.,  56.,  54.,  36.,  23.,  62.,
      119., 102., 63.,  28.,  67.,  118., 93.,  54.,  7.,   22.,  46.,  42.,
      27.,  38.,  98.,  182., 150., 90.,  89.,  206., 353., 270., 153., 70.,
      157., 262., 195., 108., 13.,  40.,  82.,  72.,  45.,  68.,  170., 308.,
      246., 144., 155., 350., 587., 438., 243., 112., 247., 406., 297., 162.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,   454.,   610.,   766.,   684.,   786.,   1545.,  1887.,  2229.,
      1842.,  1806.,  3255.,  3597.,  3939.,  3102.,  2404.,  4066.,  4366.,
      4666.,  3492.,  1964.,  3574.,  3730.,  3886.,  3084.,  4866.,  8385.,
      8727.,  9069.,  6882.,  5886.,  10095., 10437., 10779., 8142.,  6084.,
      10066., 10366., 10666., 7812.,  3724.,  6694.,  6850.,  7006.,  5484.,
      8946.,  15225., 15567., 15909., 11922., 9966.,  16935., 17277., 17619.,
      13182., 9764.,  16066., 16366., 16666., 12132.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   78.,   61.,   46.,  164.,  370.,  372.,  254.,
      154.,  428.,  838.,  732.,  458.,  203., 490.,  869.,  690.,  403.,
      41.,   142.,  311.,  294.,  193.,  262., 692.,  1306., 1092., 662.,
      658.,  1532., 2638., 2028., 1154., 527., 1186., 1985., 1482., 823.,
      77.,   262.,  563.,  510.,  325.,  478., 1220., 2242., 1812., 1070.,
      1162., 2636., 4438., 3324., 1850., 851., 1882., 3101., 2274., 1243.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,   3284.,   4484.,   5684.,   5144.,   5796.,   11550.,  14214.,
      16878.,  14052.,  13716.,  24870.,  27534.,  30198.,  23892.,  18616.,
      31556.,  33908.,  36260.,  27192.,  14872.,  27284.,  28484.,  29684.,
      23704.,  37476.,  64830.,  67494.,  70158.,  53412.,  45396.,  78150.,
      80814.,  83478.,  63252.,  47416.,  78596.,  80948.,  83300.,  61112.,
      28312.,  51284.,  52484.,  53684.,  42264.,  69156.,  118110., 120774.,
      123438., 92772.,  77076.,  131430., 134094., 136758., 102612., 76216.,
      125636., 127988., 130340., 95032.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   556.,   446.,   300.,   1144.,  2660.,  2744.,
      1900.,  1116.,  3160.,  6260.,  5528.,  3484.,  1542.,  3740.,  6658.,
      5308.,  3110.,  270.,   1004.,  2266.,  2188.,  1454.,  1932.,  5176.,
      9860.,  8312.,  5068.,  5052.,  11800., 20372., 15704., 8956.,  4086.,
      9212.,  15442., 11548., 6422.,  510.,   1868.,  4138.,  3820.,  2462.,
      3564.,  9208.,  17060., 13880., 8236.,  8988.,  20440., 34484., 25880.,
      14428., 6630.,  14684., 24226., 17788., 9734.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76.,   128.,  182.,  272.,  254.,  356.,  326.,  440.,  300.,  384.,
      330.,  456.,  669.,  876.,  831.,  1056., 993.,  1236., 834.,  1008.,
      810.,  996.,  1479., 1776., 1641., 1956., 1803., 2136., 1434., 1668.,
      1124., 1280., 1910., 2156., 2054., 2312., 2198., 2468., 1652., 1840.,
      876.,  1088., 1622., 1952., 1694., 2036., 1766., 2120., 1420., 1664.,
      2250., 2616., 3909., 4476., 4071., 4656., 4233., 4836., 3234., 3648.,
      2730., 3156., 4719., 5376., 4881., 5556., 5043., 5736., 3834., 4308.,
      2884., 3200., 4790., 5276., 4934., 5432., 5078., 5588., 3732., 4080.,
      1676., 2048., 3062., 3632., 3134., 3716., 3206., 3800., 2540., 2944.,
      4170., 4776., 7149., 8076., 7311., 8256., 7473., 8436., 5634., 6288.,
      4650., 5316., 7959., 8976., 8121., 9156., 8283., 9336., 6234., 6948.,
      4644., 5120., 7670., 8396., 7814., 8552., 7958., 8708., 5812., 6320.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,    6.,   16.,   19.,   40.,   30.,   48.,   25.,   36.,   14.,
      32.,  60.,   104., 146.,  224.,  156.,  216.,  110.,  144.,  62.,   92.,
      180., 248.,  362., 476.,  324.,  408.,  206.,  252.,  91.,   112.,  222.,
      268., 397.,  472., 318.,  372.,  187.,  216.,  13.,   28.,   54.,   88.,
      127., 184.,  126., 168.,  85.,   108.,  110.,  152.,  300.,  392.,  578.,
      728., 492.,  600., 302.,  360.,  302.,  356.,  708.,  824.,  1226., 1412.,
      948., 1080., 542., 612.,  247.,  280.,  558.,  628.,  937.,  1048., 702.,
      780., 391.,  432., 25.,   52.,   102.,  160.,  235.,  328.,  222.,  288.,
      145., 180.,  206., 272.,  540.,  680.,  1010., 1232., 828.,  984.,  494.,
      576., 542.,  620., 1236., 1400., 2090., 2348., 1572., 1752., 878.,  972.,
      403., 448.,  894., 988.,  1477., 1624., 1086., 1188., 595.,  648.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      516.,   916.,   1294.,  1990.,  1846.,  2638.,  2398.,  3286.,  2244.,
      2900.,  2406.,  3390.,  4965.,  6585.,  6225.,  7989.,  7485.,  9393.,
      6342.,  7710.,  6126.,  7590.,  11265., 13605., 12525., 15009., 13785.,
      16413., 11022., 12870., 8692.,  9924.,  14806., 16750., 15934., 17974.,
      17062., 19198., 12852., 14340., 6596.,  8276.,  12334., 14950., 12886.,
      15598., 13438., 16246., 10884., 12820., 17286., 20190., 30165., 34665.,
      31425., 36069., 32685., 37473., 25062., 28350., 21006., 24390., 36465.,
      41685., 37725., 43089., 38985., 44493., 29742., 33510., 22452., 24964.,
      37366., 41230., 38494., 42454., 39622., 43678., 29172., 31940., 12676.,
      15636., 23374., 27910., 23926., 28558., 24478., 29206., 19524., 22740.,
      32166., 36990., 55365., 62745., 56625., 64149., 57885., 65553., 43782.,
      48990., 35886., 41190., 61665., 69765., 62925., 71169., 64185., 72573.,
      48462., 54150., 36212., 40004., 59926., 65710., 61054., 66934., 62182.,
      68158., 45492., 49540.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    25.,   34.,    106.,  119.,   275.,   210.,   346.,   181.,
      265.,  82.,   218.,   404.,  740.,   1030.,  1630.,  1140.,  1604.,
      818.,  1082., 442.,   674.,  1316.,  1844.,  2686.,  3574.,  2436.,
      3092., 1562., 1922.,  689.,  853.,   1690.,  2050.,  3035.,  3623.,
      2442., 2866., 1441.,  1669., 77.,    193.,   370.,   634.,   911.,
      1355., 930.,  1258.,  637.,  817.,   802.,   1130.,  2228.,  2948.,
      4342., 5518., 3732.,  4580., 2306.,  2762.,  2314.,  2738.,  5444.,
      6356., 9454., 10918., 7332., 8372.,  4202.,  4754.,  1913.,  2173.,
      4330., 4882., 7283.,  8159., 5466.,  6082.,  3049.,  3373.,  149.,
      361.,  706.,  1162.,  1703., 2435.,  1650.,  2170.,  1093.,  1369.,
      1522., 2042., 4052.,  5156., 7654.,  9406.,  6324.,  7556.,  3794.,
      4442., 4186., 4802.,  9572., 10868., 16222., 18262., 12228., 13652.,
      6842., 7586., 3137.,  3493., 6970.,  7714.,  11531., 12695., 8490.,
      9298., 4657., 5077.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3768.,   6904.,   9716.,   15188.,  14036.,  20276.,  18356.,  25364.,
      17336.,  22520.,  18324.,  26100.,  38190.,  51006.,  48126.,  62094.,
      58062.,  73182.,  49428.,  60276.,  47604.,  59220.,  87870.,  106446.,
      97806.,  117534., 107742., 128622., 86388.,  101076., 68344.,  78136.,
      116564., 132020., 125492., 141716., 134420., 151412., 101368., 113208.,
      51128.,  64504.,  96116.,  116948., 100436., 122036., 104756., 127124.,
      85176.,  100600., 135444., 158580., 236910., 272766., 246846., 283854.,
      256782., 294942., 197268., 223476., 164724., 191700., 286590., 328206.,
      296526., 339294., 306462., 350382., 234228., 264276., 177144., 197176.,
      295124., 325940., 304052., 335636., 312980., 345332., 230648., 252728.,
      98488.,  122104., 182516., 218708., 186836., 223796., 191156., 228884.,
      153016., 178680., 252564., 291060., 435630., 494526., 445566., 505614.,
      455502., 516702., 345108., 386676., 281844., 324180., 485310., 549966.,
      495246., 561054., 505182., 572142., 382068., 427476., 285944., 316216.,
      473684., 519860., 482612., 529556., 491540., 539252., 359928., 392248.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    220.,   764.,    826.,   2026.,  1564.,  2620.,
      1374.,   2030.,   540.,   1596.,   2936.,  5560.,  7700.,  12404.,
      8696.,   12344.,  6300.,  8380.,   3324.,  5148.,  10040., 14200.,
      20660.,  27668.,  18872., 24056.,  12156., 15004., 5358.,  6654.,
      13180.,  16028.,  23722., 28378.,  19132., 22492., 11310., 13118.,
      510.,    1422.,   2716.,  4796.,   6874.,  10378., 7132.,  9724.,
      4926.,   6350.,   6108.,  8700.,   17144., 22840., 33620., 42932.,
      29048.,  35768.,  18012., 21628.,  18108., 21468., 42680., 49912.,
      74228.,  85844.,  57656., 65912.,  33084., 37468., 15054., 17118.,
      34108.,  38492.,  57418., 64378.,  43132., 48028., 24078., 26654.,
      990.,    2670.,   5212.,  8828.,   12922., 18730., 12700., 16828.,
      8478.,   10670.,  11676., 15804.,  31352., 40120., 59540., 73460.,
      49400.,  59192.,  29724., 34876.,  32892., 37788., 75320., 85624.,
      127796., 144020., 96440., 107768., 54012., 59932., 24750., 27582.,
      55036.,  60956.,  91114., 100378., 67132., 73564., 36846., 40190.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      212.,   304.,   404.,   512.,   566.,   728.,   902.,   1088.,  830.,
      1016.,  1214.,  1424.,  1094.,  1304.,  1526.,  1760.,  1044.,  1200.,
      1364.,  1536.,  1086.,  1320.,  1566.,  1824.,  2289.,  2676.,  3081.,
      3504.,  2901.,  3324.,  3765.,  4224.,  3513.,  3972.,  4449.,  4944.,
      3006.,  3336.,  3678.,  4032.,  2886.,  3240.,  3606.,  3984.,  5349.,
      5916.,  6501.,  7104.,  5961.,  6564.,  7185.,  7824.,  6573.,  7212.,
      7869.,  8544.,  5286.,  5736.,  6198.,  6672.,  4196.,  4496.,  4804.,
      5120.,  7166.,  7640.,  8126.,  8624.,  7718.,  8216.,  8726.,  9248.,
      8270.,  8792.,  9326.,  9872.,  6244.,  6608.,  6980.,  7360.,  3092.,
      3504.,  3924.,  4352.,  5846.,  6488.,  7142.,  7808.,  6110.,  6776.,
      7454.,  8144.,  6374.,  7064.,  7766.,  8480.,  5204.,  5680.,  6164.,
      6656.,  8286.,  9000.,  9726.,  10464., 14529., 15636., 16761., 17904.,
      15141., 16284., 17445., 18624., 15753., 16932., 18129., 19344., 12126.,
      12936., 13758., 14592., 10086., 10920., 11766., 12624., 17589., 18876.,
      20181., 21504., 18201., 19524., 20865., 22224., 18813., 20172., 21549.,
      22944., 14406., 15336., 16278., 17232., 10916., 11536., 12164., 12800.,
      18206., 19160., 20126., 21104., 18758., 19736., 20726., 21728., 19310.,
      20312., 21326., 22352., 14244., 14928., 15620., 16320., 5972.,  6704.,
      7444.,  8192.,  11126., 12248., 13382., 14528., 11390., 12536., 13694.,
      14864., 11654., 12824., 14006., 15200., 9364.,  10160., 10964., 11776.,
      15486., 16680., 17886., 19104., 26769., 28596., 30441., 32304., 27381.,
      29244., 31125., 33024., 27993., 29892., 31809., 33744., 21246., 22536.,
      23838., 25152., 17286., 18600., 19926., 21264., 29829., 31836., 33861.,
      35904., 30441., 32484., 34545., 36624., 31053., 33132., 35229., 37344.,
      23526., 24936., 26358., 27792., 17636., 18576., 19524., 20480., 29246.,
      30680., 32126., 33584., 29798., 31256., 32726., 34208., 30350., 31832.,
      33326., 34832., 22244., 23248., 24260., 25280.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   43.,   76.,
      115.,  160.,  90.,   120.,  154.,  192.,  81.,   100.,  121.,  144.,
      26.,   56.,   90.,   128.,  164.,  240.,  324.,  416.,  446.,  584.,
      734.,  896.,  516.,  624.,  740.,  864.,  378.,  440.,  506.,  576.,
      194.,  248.,  306.,  368.,  596.,  720.,  852.,  992.,  1238., 1448.,
      1670., 1904., 1140., 1296., 1460., 1632., 738.,  824.,  914.,  1008.,
      325.,  364.,  405.,  448.,  802.,  888.,  978.,  1072., 1447., 1588.,
      1735., 1888., 1170., 1272., 1378., 1488., 693.,  748.,  805.,  864.,
      25.,   52.,   81.,   112.,  154.,  216.,  282.,  352.,  403.,  508.,
      619.,  736.,  426.,  504.,  586.,  672.,  297.,  340.,  385.,  432.,
      362.,  440.,  522.,  608.,  1028., 1200., 1380., 1568., 2030., 2312.,
      2606., 2912., 1764., 1968., 2180., 2400., 1098., 1208., 1322., 1440.,
      1106., 1208., 1314., 1424., 2612., 2832., 3060., 3296., 4550., 4904.,
      5270., 5648., 3540., 3792., 4052., 4320., 2034., 2168., 2306., 2448.,
      925.,  988.,  1053., 1120., 2098., 2232., 2370., 2512., 3535., 3748.,
      3967., 4192., 2658., 2808., 2962., 3120., 1485., 1564., 1645., 1728.,
      49.,   100.,  153.,  208.,  298.,  408.,  522.,  640.,  763.,  940.,
      1123., 1312., 762.,  888.,  1018., 1152., 513.,  580.,  649.,  720.,
      698.,  824.,  954.,  1088., 1892., 2160., 2436., 2720., 3614., 4040.,
      4478., 4928., 3012., 3312., 3620., 3936., 1818., 1976., 2138., 2304.,
      2018., 2168., 2322., 2480., 4628., 4944., 5268., 5600., 7862., 8360.,
      8870., 9392., 5940., 6288., 6644., 7008., 3330., 3512., 3698., 3888.,
      1525., 1612., 1701., 1792., 3394., 3576., 3762., 3952., 5623., 5908.,
      6199., 6496., 4146., 4344., 4546., 4752., 2277., 2380., 2485., 2592.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1524.,   2244.,   3028.,   3876.,   4222.,   5494.,   6862.,   8326.,
      6286.,   7750.,   9310.,   10966.,  8350.,   10006.,  11758.,  13606.,
      8052.,   9284.,   10580.,  11940.,  8238.,   10086.,  12030.,  14070.,
      17565.,  20625.,  23829.,  27177.,  22389.,  25737.,  29229.,  32865.,
      27213.,  30849.,  34629.,  38553.,  23406.,  26022.,  28734.,  31542.,
      22398.,  25206.,  28110.,  31110.,  41685.,  46185.,  50829.,  55617.,
      46509.,  51297.,  56229.,  61305.,  51333.,  56409.,  61629.,  66993.,
      41406.,  44982.,  48654.,  52422.,  32980.,  35364.,  37812.,  40324.,
      56398.,  60166.,  64030.,  67990.,  60766.,  64726.,  68782.,  72934.,
      65134.,  69286.,  73534.,  77878.,  49236.,  52132.,  55092.,  58116.,
      23924.,  27204.,  30548.,  33956.,  45502.,  50614.,  55822.,  61126.,
      47566.,  52870.,  58270.,  63766.,  49630.,  55126.,  60718.,  66406.,
      40692.,  44484.,  48340.,  52260.,  64878.,  70566.,  76350.,  82230.,
      114045., 122865., 131829., 140937., 118869., 127977., 137229., 146625.,
      123693., 133089., 142629., 152313., 95406.,  101862., 108414., 115062.,
      79038.,  85686.,  92430.,  99270.,  138165., 148425., 158829., 169377.,
      142989., 153537., 164229., 175065., 147813., 158649., 169629., 180753.,
      113406., 120822., 128334., 135942., 86100.,  91044.,  96052.,  101124.,
      143758., 151366., 159070., 166870., 148126., 155926., 163822., 171814.,
      152494., 160486., 168574., 176758., 112596., 118052., 123572., 129156.,
      46324.,  52164.,  58068.,  64036.,  86782.,  95734.,  104782., 113926.,
      88846.,  97990.,  107230., 116566., 90910.,  100246., 109678., 119206.,
      73332.,  79684.,  86100.,  92580.,  121518., 131046., 140670., 150390.,
      210525., 225105., 239829., 254697., 215349., 230217., 245229., 260385.,
      220173., 235329., 250629., 266073., 167406., 177702., 188094., 198582.,
      135678., 146166., 156750., 167430., 234645., 250665., 266829., 283137.,
      239469., 255777., 272229., 288825., 244293., 260889., 277629., 294513.,
      185406., 196662., 208014., 219462., 139220., 146724., 154292., 161924.,
      231118., 242566., 254110., 265750., 235486., 247126., 258862., 270694.,
      239854., 251686., 263614., 275638., 175956., 183972., 192052., 200196.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   287.,
      539.,   839.,   1187.,  666.,   898.,   1162.,  1458.,  613.,   761.,
      925.,   1105.,  154.,   386.,   650.,   946.,   1172.,  1764.,  2420.,
      3140.,  3310.,  4390.,  5566.,  6838.,  3924.,  4772.,  5684.,  6660.,
      2906.,  3394.,  3914.,  4466.,  1450.,  1874.,  2330.,  2818.,  4532.,
      5508.,  6548.,  7652.,  9502.,  11158., 12910., 14758., 8820.,  10052.,
      11348., 12708., 5738.,  6418.,  7130.,  7874.,  2525.,  2833.,  3157.,
      3497.,  6250.,  6930.,  7642.,  8386.,  11303., 12419., 13583., 14795.,
      9162.,  9970.,  10810., 11682., 5437.,  5873.,  6325.,  6793.,  149.,
      361.,   589.,   833.,   1114.,  1602.,  2122.,  2674.,  3023.,  3851.,
      4727.,  5651.,  3258.,  3874.,  4522.,  5202.,  2293.,  2633.,  2989.,
      3361.,  2746.,  3362.,  4010.,  4690.,  7892.,  9252.,  10676., 12164.,
      15694., 17926., 20254., 22678., 13716., 15332., 17012., 18756., 8570.,
      9442.,  10346., 11282., 8650.,  9458.,  10298., 11170., 20468., 22212.,
      24020., 25892., 35710., 38518., 41422., 44422., 27828., 29828., 31892.,
      34020., 16010., 17074., 18170., 19298., 7277.,  7777.,  8293.,  8825.,
      16522., 17586., 18682., 19810., 27863., 29555., 31295., 33083., 20970.,
      22162., 23386., 24642., 11725., 12353., 12997., 13657., 293.,   697.,
      1117.,  1553.,  2170.,  3042.,  3946.,  4882.,  5759.,  7163.,  8615.,
      10115., 5850.,  6850.,  7882.,  8946.,  3973.,  4505.,  5053.,  5617.,
      5338.,  6338.,  7370.,  8434.,  14612., 16740., 18932., 21188., 28078.,
      31462., 34942., 38518., 23508., 25892., 28340., 30852., 14234., 15490.,
      16778., 18098., 15850., 17042., 18266., 19522., 36404., 38916., 41492.,
      44132., 61918., 65878., 69934., 74086., 46836., 49604., 52436., 55332.,
      26282., 27730., 29210., 30722., 12029., 12721., 13429., 14153., 26794.,
      28242., 29722., 31234., 44423., 46691., 49007., 51371., 32778., 34354.,
      35962., 37602., 18013., 18833., 19669., 20521.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11512.,   17208.,   23416.,   30136.,   32564.,   42644.,   53492.,
      65108.,   48884.,   60500.,   72884.,   86036.,   65204.,   78356.,
      92276.,   106964.,  63224.,   73016.,   83320.,   94136.,   64116.,
      78804.,   94260.,   110484.,  137550.,  161886.,  187374.,  214014.,
      175854.,  202494.,  230286.,  259230.,  214158.,  243102.,  273198.,
      304446.,  184692.,  205524.,  227124.,  249492.,  176436.,  198804.,
      221940.,  245844.,  329070.,  364926.,  401934.,  440094.,  367374.,
      405534.,  444846.,  485310.,  405678.,  446142.,  487758.,  530526.,
      327732.,  356244.,  385524.,  415572.,  261496.,  280504.,  300024.,
      320056.,  447476.,  477524.,  508340.,  539924.,  482228.,  513812.,
      546164.,  579284.,  516980.,  550100.,  583988.,  618644.,  391032.,
      414136.,  437752.,  461880.,  188152.,  214328.,  241016.,  268216.,
      358964.,  399764.,  441332.,  483668.,  375284.,  417620.,  460724.,
      504596.,  391604.,  435476.,  480116.,  525524.,  321784.,  352056.,
      382840.,  414136.,  513396.,  558804.,  604980.,  651924.,  903630.,
      974046.,  1045614., 1118334., 941934.,  1014654., 1088526., 1163550.,
      980238.,  1055262., 1131438., 1208766., 756852.,  808404.,  860724.,
      913812.,  625716.,  678804.,  732660.,  787284.,  1095150., 1177086.,
      1260174., 1344414., 1133454., 1217694., 1303086., 1389630., 1171758.,
      1258302., 1345998., 1434846., 899892.,  959124.,  1019124., 1079892.,
      683896.,  723384.,  763384.,  803896.,  1142516., 1203284., 1264820.,
      1327124., 1177268., 1239572., 1302644., 1366484., 1212020., 1275860.,
      1340468., 1405844., 895352.,  938936.,  983032.,  1027640., 364792.,
      411448.,  458616.,  506296.,  685364.,  756884.,  829172.,  902228.,
      701684.,  774740.,  848564.,  923156.,  718004.,  792596.,  867956.,
      944084.,  580344.,  631096.,  682360.,  734136.,  962676.,  1038804.,
      1115700., 1193364., 1669710., 1786206., 1903854., 2022654., 1708014.,
      1826814., 1946766., 2067870., 1746318., 1867422., 1989678., 2113086.,
      1329012., 1411284., 1494324., 1578132., 1074996., 1158804., 1243380.,
      1328724., 1861230., 1989246., 2118414., 2248734., 1899534., 2029854.,
      2161326., 2293950., 1937838., 2070462., 2204238., 2339166., 1472052.,
      1562004., 1652724., 1744212., 1106296., 1166264., 1226744., 1287736.,
      1837556., 1929044., 2021300., 2114324., 1872308., 1965332., 2059124.,
      2153684., 1907060., 2001620., 2096948., 2193044., 1399672., 1463736.,
      1528312., 1593400.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      2074.,   4042.,   6394.,   9130.,   5116.,   6940.,   9020.,   11356.,
      4766.,   5934.,   7230.,   8654.,   1020.,   2844.,   4924.,   7260.,
      8824.,   13496.,  18680.,  24376.,  25460.,  34004.,  43316.,  53396.,
      30584.,  37304.,  44536.,  52280.,  22780.,  26652.,  30780.,  35164.,
      11196.,  14556.,  18172.,  22044.,  35320.,  43064.,  51320.,  60088.,
      74420.,  87572.,  101492., 116180., 69368.,  79160.,  89464.,  100280.,
      45244.,  50652.,  56316.,  62236.,  19902.,  22350.,  24926.,  27630.,
      49340.,  54748.,  60412.,  66332.,  89338.,  98218.,  107482., 117130.,
      72508.,  78940.,  85628.,  92572.,  43070.,  46542.,  50142.,  53870.,
      990.,    2670.,   4478.,   6414.,   8444.,   12316.,  16444.,  20828.,
      23386.,  29962.,  36922.,  44266.,  25468.,  30364.,  35516.,  40924.,
      18014.,  20718.,  23550.,  26510.,  21372.,  26268.,  31420.,  36828.,
      61816.,  72632.,  83960.,  95800.,  123380., 141140., 159668., 178964.,
      108152., 121016., 134392., 148280., 67708.,  74652.,  81852.,  89308.,
      68412.,  74844.,  81532.,  88476.,  162040., 175928., 190328., 205240.,
      282932., 305300., 328436., 352340., 220664., 236600., 253048., 270008.,
      127036., 135516., 144252., 153244., 57726.,  61710.,  65822.,  70062.,
      131132., 139612., 148348., 157340., 221242., 234730., 248602., 262858.,
      166588., 176092., 185852., 195868., 93182.,  98190.,  103326., 108590.,
      1950.,   5166.,   8510.,   11982.,  16508.,  23452.,  30652.,  38108.,
      44698.,  55882.,  67450.,  79402.,  45820.,  53788.,  62012.,  70492.,
      31262.,  35502.,  39870.,  44366.,  41724.,  49692.,  57916.,  66396.,
      114808., 131768., 149240., 167224., 221300., 248276., 276020., 304532.,
      185720., 204728., 224248., 244280., 112636., 122652., 132924., 143452.,
      125628., 135132., 144892., 154908., 288760., 308792., 329336., 350392.,
      491444., 523028., 555380., 588500., 371960., 394040., 416632., 439736.,
      208828., 220380., 232188., 244252., 95550.,  101070., 106718., 112494.,
      212924., 224476., 236284., 248348., 353146., 371242., 389722., 408586.,
      260668., 273244., 286076., 299164., 143294., 149838., 156510., 163310.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,   74.,   95.,   116.,  137.,  117.,  129.,  246.,  291.,
      336.,  381.,  306.,  291.,  516.,  561.,  606.,  651.,  504.,
      377.,  632.,  671.,  710.,  749.,  555.,  323.,  578.,  599.,
      620.,  641.,  501.,  777.,  1326., 1371., 1416., 1461., 1098.,
      939.,  1596., 1641., 1686., 1731., 1296., 953.,  1568., 1607.,
      1646., 1685., 1227., 611.,  1082., 1103., 1124., 1145., 885.,
      1425., 2406., 2451., 2496., 2541., 1890., 1587., 2676., 2721.,
      2766., 2811., 2088., 1529., 2504., 2543., 2582., 2621., 1899.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  16.,  17.,  12.,  9.,   29.,  62.,  83.,  75.,  48.,
      27.,  71.,  134., 173., 141., 84.,  35.,  82.,  142., 166., 127., 72.,
      9.,   28.,  58.,  64.,  57.,  36.,  49.,  125., 230., 251., 203., 120.,
      115., 263., 446., 485., 365., 204., 91.,  202., 334., 358., 263., 144.,
      17.,  52.,  106., 112., 97.,  60.,  89.,  221., 398., 419., 331., 192.,
      203., 455., 758., 797., 589., 324., 147., 322., 526., 550., 399., 216.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,   496.,   652.,   808.,   964.,   840.,   894.,   1743.,  2085.,
      2427.,  2769.,  2250.,  2118.,  3795.,  4137.,  4479.,  4821.,  3762.,
      2840.,  4780.,  5080.,  5380.,  5680.,  4224.,  2336.,  4240.,  4396.,
      4552.,  4708.,  3720.,  5790.,  9951.,  10293., 10635., 10977., 8298.,
      7014.,  12003., 12345., 12687., 13029., 9810.,  7256.,  11980., 12280.,
      12580., 12880., 9408.,  4448.,  7984.,  8140.,  8296.,  8452.,  6600.,
      10686., 18159., 18501., 18843., 19185., 14346., 11910., 20211., 20553.,
      20895., 21237., 15858., 11672., 19180., 19480., 19780., 20080., 14592.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   101.,  114.,  83.,   52.,   184.,  412.,
      568.,  528.,  344.,  184.,  496.,  952.,  1252., 1032., 620.,
      257.,  606.,  1055., 1241., 954.,  543.,  53.,   182.,  395.,
      437.,  402.,  259.,  340.,  888.,  1660., 1816., 1488., 888.,
      856.,  1968., 3352., 3652., 2760., 1548., 689.,  1534., 2543.,
      2729., 2010., 1103., 101.,  342.,  731.,  773.,  690.,  435.,
      628.,  1592., 2908., 3064., 2448., 1432., 1528., 3440., 5752.,
      6052., 4488., 2476., 1121., 2462., 4031., 4217., 3066., 1663.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,   3596.,   4796.,   5996.,   7196.,   6344.,   6612.,   13062.,
      15726.,  18390.,  21054.,  17220.,  16116.,  29046.,  31710.,  34374.,
      37038.,  29028.,  22024.,  37148.,  39500.,  41852.,  44204.,  32936.,
      17704.,  32396.,  33596.,  34796.,  35996.,  28616.,  44628.,  76998.,
      79662.,  82326.,  84990.,  64452.,  54132.,  92982.,  95646.,  98310.,
      100974., 76260.,  56584.,  93596.,  95948.,  98300.,  100652., 73640.,
      33832.,  61196.,  62396.,  63596.,  64796.,  50888.,  82644.,  140934.,
      143598., 146262., 148926., 111684., 92148.,  156918., 159582., 162246.,
      164910., 123492., 91144.,  150044., 152396., 154748., 157100., 114344.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   706.,   828.,   614.,   340.,   1288.,  2972.,
      4172.,  3944.,  2596.,  1348.,  3688.,  7148.,  9500.,  7880.,  4756.,
      1966.,  4652.,  8122.,  9586.,  7388.,  4214.,  350.,   1292.,  2890.,
      3202.,  3004.,  1958.,  2516.,  6664.,  12572., 13772., 11368., 6820.,
      6596.,  15208., 25964., 28316., 21448., 12052., 5358.,  11948., 19834.,
      21298., 15708., 8630.,  670.,   2444.,  5386.,  5698.,  5180.,  3302.,
      4692.,  12040., 22172., 23372., 18792., 11044., 11844., 26728., 44780.,
      47132., 35016., 19348., 8750.,  19244., 31546., 33010., 24028., 13046.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84.,   140.,   200.,  296.,   272.,  380.,   344.,  464.,   416.,  548.,
      372.,  468.,   378.,  516.,   759.,  984.,   921.,  1164.,  1083., 1344.,
      1245., 1524.,  1026., 1224.,  954.,  1164.,  1731., 2064.,  1893., 2244.,
      2055., 2424.,  2217., 2604.,  1746., 2016.,  1332., 1508.,  2252., 2528.,
      2396., 2684.,  2540., 2840.,  2684., 2996.,  2004., 2220.,  1044., 1292.,
      1928., 2312.,  2000., 2396.,  2072., 2480.,  2144., 2564.,  1716., 2004.,
      2682., 3108.,  4647., 5304.,  4809., 5484.,  4971., 5664.,  5133., 5844.,
      3906., 4392.,  3258., 3756.,  5619., 6384.,  5781., 6564.,  5943., 6744.,
      6105., 6924.,  4626., 5184.,  3444., 3812.,  5708., 6272.,  5852., 6428.,
      5996., 6584.,  6140., 6740.,  4500., 4908.,  2004., 2444.,  3656., 4328.,
      3728., 4412.,  3800., 4496.,  3872., 4580.,  3060., 3540.,  4986., 5700.,
      8535., 9624.,  8697., 9804.,  8859., 9984.,  9021., 10164., 6786., 7560.,
      5562., 6348.,  9507., 10704., 9669., 10884., 9831., 11064., 9993., 11244.,
      7506., 8352.,  5556., 6116.,  9164., 10016., 9308., 10172., 9452., 10328.,
      9596., 10484., 6996., 7596.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    6.,    16.,   19.,   40.,   37.,   64.,   46.,   68.,
      35.,   48.,   16.,   36.,   68.,   116.,  164.,  248.,  236.,  332.,
      228.,  300.,  152.,  192.,  76.,   108.,  212.,  284.,  416.,  536.,
      560.,  692.,  468.,  564.,  284.,  336.,  117.,  140.,  278.,  328.,
      487.,  568.,  577.,  664.,  446.,  508.,  255.,  288.,  17.,   36.,
      70.,   112.,  163.,  232.,  181.,  256.,  174.,  228.,  115.,  144.,
      144.,  196.,  388.,  500.,  740.,  920.,  812.,  1004., 676.,  812.,
      408.,  480.,  396.,  460.,  916.,  1052., 1568., 1784., 1712., 1940.,
      1300., 1460., 732.,  816.,  325.,  364.,  726.,  808.,  1207., 1336.,
      1297., 1432., 958.,  1052., 527.,  576.,  33.,   68.,   134.,  208.,
      307.,  424.,  325.,  448.,  302.,  388.,  195.,  240.,  272.,  356.,
      708.,  884.,  1316., 1592., 1388., 1676., 1124., 1324., 664.,  768.,
      716.,  812.,  1620., 1820., 2720., 3032., 2864., 3188., 2132., 2356.,
      1180., 1296., 533.,  588.,  1174., 1288., 1927., 2104., 2017., 2200.,
      1470., 1596., 799.,  864.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      572.,   1004.,  1426.,  2170.,  1978.,  2818.,  2530.,  3466.,  3082.,
      4114.,  2796.,  3548.,  2766.,  3846.,  5649.,  7413.,  6909.,  8817.,
      8169.,  10221., 9429.,  11625., 7830.,  9390.,  7230.,  8886.,  13209.,
      15837., 14469., 17241., 15729., 18645., 16989., 20049., 13446., 15582.,
      10316., 11708., 17482., 19666., 18610., 20890., 19738., 22114., 20866.,
      23338., 15612., 17324., 7868.,  9836.,  14674., 17722., 15226., 18370.,
      15778., 19018., 16330., 19666., 13164., 15452., 20622., 24006., 35889.,
      41109., 37149., 42513., 38409., 43917., 39669., 45321., 30294., 34158.,
      25086., 29046., 43449., 49533., 44709., 50937., 45969., 52341., 47229.,
      53745., 35910., 40350., 26828., 29756., 44554., 49042., 45682., 50266.,
      46810., 51490., 47938., 52714., 35196., 38444., 15164., 18668., 27922.,
      33274., 28474., 33922., 29026., 34570., 29578., 35218., 23532., 27356.,
      38478., 44166., 66129., 74805., 67389., 76209., 68649., 77613., 69909.,
      79017., 52758., 58926., 42942., 49206., 73689., 83229., 74949., 84633.,
      76209., 86037., 77469., 87441., 58374., 65118., 43340., 47804., 71626.,
      78418., 72754., 79642., 73882., 80866., 75010., 82090., 54780., 59564.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    34.,    106.,   119.,   275.,   251.,   455.,   330.,
      498.,   257.,   357.,   94.,    246.,   460.,   828.,   1162.,  1810.,
      1714.,  2458.,  1692.,  2252.,  1142.,  1454.,  550.,   798.,   1564.,
      2124.,  3106.,  4042.,  4234.,  5266.,  3564.,  4316.,  2174.,  2582.,
      893.,   1073.,  2130.,  2522.,  3743.,  4379.,  4451.,  5135.,  3450.,
      3938.,  1977.,  2237.,  101.,   249.,   482.,   810.,   1175.,  1715.,
      1307.,  1895.,  1290.,  1714.,  865.,   1093.,  1054.,  1462.,  2892.,
      3772.,  5578.,  6994.,  6130.,  7642.,  5148.,  6220.,  3126.,  3694.,
      3046.,  3550.,  7068.,  8140.,  12130., 13834., 13258., 15058., 10092.,
      11356., 5694.,  6358.,  2525.,  2833.,  5650.,  6298.,  9407.,  10427.,
      10115., 11183., 7482.,  8226.,  4121.,  4509.,  197.,   473.,   930.,
      1514.,  2231.,  3155.,  2363.,  3335.,  2250.,  2930.,  1473.,  1829.,
      2014.,  2678.,  5324.,  6716.,  9994.,  12178., 10546., 12826., 8604.,
      10188., 5110.,  5934.,  5542.,  6302.,  12572., 14156., 21154., 23626.,
      22282., 24850., 16620., 18396., 9214.,  10134., 4157.,  4593.,  9170.,
      10074., 15071., 16475., 15779., 17231., 11514., 12514., 6265.,  6781.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4184.,   7576.,   10724.,  16580.,  15044.,  21668.,  19364.,  26756.,
      23684.,  31844.,  21656.,  27608.,  21108.,  29652.,  43518.,  57486.,
      53454.,  68574.,  63390.,  79662.,  73326.,  90750.,  61140.,  73524.,
      56244.,  69396.,  103134., 124014., 113070., 135102., 123006., 146190.,
      132942., 157278., 105492., 122484., 81176.,  92248.,  137732., 155108.,
      146660., 164804., 155588., 174500., 164516., 184196., 123224., 136856.,
      61016.,  76696.,  114404., 138692., 118724., 143780., 123044., 148868.,
      127364., 153956., 103064., 121304., 161652., 188628., 281982., 323598.,
      291918., 334686., 301854., 345774., 311790., 356862., 238548., 269364.,
      196788., 228372., 341598., 390126., 351534., 401214., 361470., 412302.,
      371406., 423390., 282900., 318324., 211736., 235096., 352004., 387812.,
      360932., 397508., 369860., 407204., 378788., 416900., 278360., 304280.,
      117848., 145816., 218084., 260804., 222404., 265892., 226724., 270980.,
      231044., 276068., 184472., 215000., 302196., 347604., 520446., 589710.,
      530382., 600798., 540318., 611886., 550254., 622974., 415956., 465204.,
      337332., 387348., 580062., 656238., 589998., 667326., 599934., 678414.,
      609870., 689502., 460308., 514164., 342296., 377944., 566276., 620516.,
      575204., 630212., 584132., 639908., 593060., 649604., 433496., 471704.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    220.,    764.,    826.,    2026.,   1834.,   3418.,
      2492.,   3804.,   1966.,   2750.,   620.,    1804.,   3352.,   6232.,
      8708.,   13796.,  13028.,  18884.,  13016.,  17432.,  8844.,   11308.,
      4172.,   6124.,   11992.,  16408.,  23972.,  31364.,  32900.,  41060.,
      27800.,  33752.,  17004.,  20236.,  6974.,   8398.,   16668.,  19772.,
      29338.,  34378.,  34954.,  40378.,  27132.,  31004.,  15566.,  17630.,
      670.,    1838.,   3548.,   6140.,   8890.,   13162.,  9898.,   14554.,
      9916.,   13276.,  6702.,   8510.,   8044.,   11276.,  22296.,  29272.,
      43268.,  54500.,  47588.,  59588.,  40152.,  48664.,  24460.,  28972.,
      23884.,  27884.,  55512.,  64024.,  95396.,  108932., 104324., 118628.,
      79512.,  89560.,  44908.,  50188.,  19902.,  22350.,  44572.,  49724.,
      74266.,  82378.,  79882.,  88378.,  59132.,  65052.,  32590.,  35678.,
      1310.,   3502.,   6876.,   11516.,  16954.,  24298.,  17962.,  25690.,
      17340.,  22748.,  11438.,  14270.,  15468.,  20748.,  41240.,  52312.,
      77828.,  95204.,  82148.,  100292., 67288.,  79896.,  40076.,  46636.,
      43596.,  49644.,  99032.,  111640., 166820., 186500., 175748., 196196.,
      131224., 145368., 72812.,  80140.,  32830.,  36302.,  72476.,  79676.,
      119194., 130378., 124810., 136378., 91132.,  99100.,  49614.,  53726.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236.,   336.,   444.,   560.,   626.,   800.,   986.,   1184.,  890.,
      1088.,  1298.,  1520.,  1154.,  1376.,  1610.,  1856.,  1418.,  1664.,
      1922.,  2192.,  1308.,  1488.,  1676.,  1872.,  1254.,  1512.,  1782.,
      2064.,  2613.,  3036.,  3477.,  3936.,  3225.,  3684.,  4161.,  4656.,
      3837.,  4332.,  4845.,  5376.,  4449.,  4980.,  5529.,  6096.,  3726.,
      4104.,  4494.,  4896.,  3414.,  3816.,  4230.,  4656.,  6285.,  6924.,
      7581.,  8256.,  6897.,  7572.,  8265.,  8976.,  7509.,  8220.,  8949.,
      9696.,  8121.,  8868.,  9633.,  10416., 6462.,  6984.,  7518.,  8064.,
      4988.,  5328.,  5676.,  6032.,  8474.,  9008.,  9554.,  10112., 9026.,
      9584.,  10154., 10736., 9578.,  10160., 10754., 11360., 10130., 10736.,
      11354., 11984., 7596.,  8016.,  8444.,  8880.,  3692.,  4176.,  4668.,
      5168.,  6962.,  7712.,  8474.,  9248.,  7226.,  8000.,  8786.,  9584.,
      7490.,  8288.,  9098.,  9920.,  7754.,  8576.,  9410.,  10256., 6300.,
      6864.,  7436.,  8016.,  9894.,  10728., 11574., 12432., 17301., 18588.,
      19893., 21216., 17913., 19236., 20577., 21936., 18525., 19884., 21261.,
      22656., 19137., 20532., 21945., 23376., 14670., 15624., 16590., 17568.,
      12054., 13032., 14022., 15024., 20973., 22476., 23997., 25536., 21585.,
      23124., 24681., 26256., 22197., 23772., 25365., 26976., 22809., 24420.,
      26049., 27696., 17406., 18504., 19614., 20736., 13052., 13776., 14508.,
      15248., 21722., 22832., 23954., 25088., 22274., 23408., 24554., 25712.,
      22826., 23984., 25154., 26336., 23378., 24560., 25754., 26960., 17196.,
      18000., 18812., 19632., 7148.,  8016.,  8892.,  9776.,  13298., 14624.,
      15962., 17312., 13562., 14912., 16274., 17648., 13826., 15200., 16586.,
      17984., 14090., 15488., 16898., 18320., 11292., 12240., 13196., 14160.,
      18534., 19944., 21366., 22800., 31989., 34140., 36309., 38496., 32601.,
      34788., 36993., 39216., 33213., 35436., 37677., 39936., 33825., 36084.,
      38361., 40656., 25614., 27144., 28686., 30240., 20694., 22248., 23814.,
      25392., 35661., 38028., 40413., 42816., 36273., 38676., 41097., 43536.,
      36885., 39324., 41781., 44256., 37497., 39972., 42465., 44976., 28350.,
      30024., 31710., 33408., 21116., 22224., 23340., 24464., 34970., 36656.,
      38354., 40064., 35522., 37232., 38954., 40688., 36074., 37808., 39554.,
      41312., 36626., 38384., 40154., 41936., 26796., 27984., 29180., 30384.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,     4.,     9.,     16.,    10.,   24.,    42.,    64.,    43.,
      76.,    115.,   160.,   103.,   148.,  199.,   256.,   146.,   184.,
      226.,   272.,   117.,   140.,   165.,  192.,   30.,    64.,    102.,
      144.,   188.,   272.,   364.,   464.,  506.,   656.,   818.,   992.,
      770.,   944.,   1130.,  1328.,  780.,  912.,   1052.,  1200.,  534.,
      608.,   686.,   768.,   246.,   304.,  366.,   432.,   716.,   848.,
      988.,   1136.,  1442.,  1664.,  1898., 2144.,  1994.,  2240.,  2498.,
      2768.,  1692.,  1872.,  2060.,  2256., 1038.,  1136.,  1238.,  1344.,
      425.,   468.,   513.,   560.,   1018., 1112.,  1210.,  1312.,  1795.,
      1948.,  2107.,  2272.,  2143.,  2308., 2479.,  2656.,  1666.,  1784.,
      1906.,  2032.,  957.,   1020.,  1085., 1152.,  33.,    68.,    105.,
      144.,   202.,   280.,   362.,   448.,  523.,   652.,   787.,   928.,
      583.,   724.,   871.,   1024.,  594.,  696.,   802.,   912.,   405.,
      460.,   517.,   576.,   478.,   576.,  678.,   784.,   1340.,  1552.,
      1772.,  2000.,  2618.,  2960.,  3314., 3680.,  2882.,  3248.,  3626.,
      4016.,  2444.,  2704.,  2972.,  3248., 1494.,  1632.,  1774.,  1920.,
      1462.,  1584.,  1710.,  1840.,  3404., 3664.,  3932.,  4208.,  5858.,
      6272.,  6698.,  7136.,  6410.,  6848., 7298.,  7760.,  4892.,  5200.,
      5516.,  5840.,  2766.,  2928.,  3094., 3264.,  1225.,  1300.,  1377.,
      1456.,  2746.,  2904.,  3066.,  3232., 4579.,  4828.,  5083.,  5344.,
      4927.,  5188.,  5455.,  5728.,  3650., 3832.,  4018.,  4208.,  2013.,
      2108.,  2205.,  2304.,  65.,    132.,  201.,   272.,   394.,   536.,
      682.,   832.,   1003.,  1228.,  1459., 1696.,  1063.,  1300.,  1543.,
      1792.,  1042.,  1208.,  1378.,  1552., 693.,   780.,   869.,   960.,
      926.,   1088.,  1254.,  1424.,  2492., 2832.,  3180.,  3536.,  4730.,
      5264.,  5810.,  6368.,  4994.,  5552., 6122.,  6704.,  4108.,  4496.,
      4892.,  5296.,  2454.,  2656.,  2862., 3072.,  2678.,  2864.,  3054.,
      3248.,  6092.,  6480.,  6876.,  7280., 10274., 10880., 11498., 12128.,
      10826., 11456., 12098., 12752., 8092., 8528.,  8972.,  9424.,  4494.,
      4720.,  4950.,  5184.,  2025.,  2132., 2241.,  2352.,  4474.,  4696.,
      4922.,  5152.,  7363.,  7708.,  8059., 8416.,  7711.,  8068.,  8431.,
      8800.,  5634.,  5880.,  6130.,  6384., 3069.,  3196.,  3325.,  3456.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1700.,   2484.,   3332.,   4244.,   4678.,   6046.,   7510.,   9070.,
      6742.,   8302.,   9958.,   11710.,  8806.,   10558.,  12406.,  14350.,
      10870.,  12814.,  14854.,  16990.,  10116.,  11540.,  13028.,  14580.,
      9534.,   11574.,  13710.,  15942.,  20085.,  23433.,  26925.,  30561.,
      24909.,  28545.,  32325.,  36249.,  29733.,  33657.,  37725.,  41937.,
      34557.,  38769.,  43125.,  47625.,  29070.,  32070.,  35166.,  38358.,
      26526.,  29718.,  33006.,  36390.,  49029.,  54105.,  59325.,  64689.,
      53853.,  59217.,  64725.,  70377.,  58677.,  64329.,  70125.,  76065.,
      63501.,  69441.,  75525.,  81753.,  50670.,  54822.,  59070.,  63414.,
      39236.,  41940.,  44708.,  47540.,  66742.,  70990.,  75334.,  79774.,
      71110.,  75550.,  80086.,  84718.,  75478.,  80110.,  84838.,  89662.,
      79846.,  84670.,  89590.,  94606.,  59940.,  63284.,  66692.,  70164.,
      28580.,  32436.,  36356.,  40340.,  54214.,  60190.,  66262.,  72430.,
      56278.,  62446.,  68710.,  75070.,  58342.,  64702.,  71158.,  77710.,
      60406.,  66958.,  73606.,  80350.,  49284.,  53780.,  58340.,  62964.,
      77502.,  84150.,  90894.,  97734.,  135861., 146121., 156525., 167073.,
      140685., 151233., 161925., 172761., 145509., 156345., 167325., 178449.,
      150333., 161457., 172725., 184137., 115470., 123078., 130782., 138582.,
      94494.,  102294., 110190., 118182., 164805., 176793., 188925., 201201.,
      169629., 181905., 194325., 206889., 174453., 187017., 199725., 212577.,
      179277., 192129., 205125., 218265., 137070., 145830., 154686., 163638.,
      102980., 108756., 114596., 120500., 171574., 180430., 189382., 198430.,
      175942., 184990., 194134., 203374., 180310., 189550., 198886., 208318.,
      184678., 194110., 203638., 213262., 135972., 142388., 148868., 155412.,
      55460.,  62388.,  69380.,  76436.,  103750., 114334., 125014., 135790.,
      105814., 116590., 127462., 138430., 107878., 118846., 129910., 141070.,
      109942., 121102., 132358., 143710., 88452.,  96020.,  103652., 111348.,
      145470., 156726., 168078., 179526., 251637., 268809., 286125., 303585.,
      256461., 273921., 291525., 309273., 261285., 279033., 296925., 314961.,
      266109., 284145., 302325., 320649., 201870., 214086., 226398., 238806.,
      162462., 174870., 187374., 199974., 280581., 299481., 318525., 337713.,
      285405., 304593., 323925., 343401., 290229., 309705., 329325., 349089.,
      295053., 314817., 334725., 354777., 223470., 236838., 250302., 263862.,
      166724., 175572., 184484., 193460., 276406., 289870., 303430., 317086.,
      280774., 294430., 308182., 322030., 285142., 298990., 312934., 326974.,
      289510., 303550., 317686., 331918., 212004., 221492., 231044., 240660.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,    58.,    162.,   298.,   466.,   287.,
      539.,   839.,   1187.,  743.,    1091.,  1487.,  1931.,  1098.,  1394.,
      1722.,  2082.,  893.,   1073.,   1269.,  1481.,  178.,   442.,   738.,
      1066.,  1348.,  2004.,  2724.,   3508.,  3766.,  4942.,  6214.,  7582.,
      5830.,  7198.,  8662.,  10222.,  5988.,  7028.,  8132.,  9300.,  4130.,
      4714.,  5330.,  5978.,  1858.,   2314.,  2802.,  3322.,  5476.,  6516.,
      7620.,  8788.,  11110., 12862.,  14710., 16654., 15478., 17422., 19462.,
      21598., 13188., 14612., 16100.,  17652., 8114.,  8890.,  9698.,  10538.,
      3317.,  3657.,  4013.,  4385.,   7962.,  8706.,  9482.,  10290., 14063.,
      15275., 16535., 17843., 16823.,  18131., 19487., 20891., 13098., 14034.,
      15002., 16002., 7533.,  8033.,   8549.,  9081.,  197.,   473.,   765.,
      1073.,  1466.,  2082.,  2730.,   3410.,  3935.,  4955.,  6023.,  7139.,
      4391.,  5507.,  6671.,  7883.,   4554.,  5362.,  6202.,  7074.,  3133.,
      3569.,  4021.,  4489.,  3634.,   4410.,  5218.,  6058.,  10308., 11988.,
      13732., 15540., 20278., 22990.,  25798., 28702., 22342., 25246., 28246.,
      31342., 19044., 21108., 23236.,  25428., 11682., 12778., 13906., 15066.,
      11458., 12426., 13426., 14458.,  26724., 28788., 30916., 33108., 46054.,
      49342., 52726., 56206., 50422.,  53902., 57478., 61150., 38532., 40980.,
      43492., 46068., 21810., 23098.,  24418., 25770., 9653.,  10249., 10861.,
      11489., 21658., 22914., 24202.,  25522., 36143., 38123., 40151., 42227.,
      38903., 40979., 43103., 45275.,  28842., 30290., 31770., 33282., 15917.,
      16673., 17445., 18233., 389.,    921.,   1469.,  2033.,  2874.,  4002.,
      5162.,  6354.,  7583.,  9371.,   11207., 13091., 8039.,  9923.,  11855.,
      13835., 8010.,  9330.,  10682.,  12066., 5373.,  6065.,  6773.,  7497.,
      7090.,  8378.,  9698.,  11050.,  19268., 21972., 24740., 27572., 36790.,
      41038., 45382., 49822., 38854.,  43294., 47830., 52462., 32100., 35188.,
      38340., 41556., 19234., 20842.,  22482., 24154., 21058., 22538., 24050.,
      25594., 47972., 51060., 54212.,  57428., 80998., 85822., 90742., 95758.,
      85366., 90382., 95494., 100702., 63876., 67348., 70884., 74484., 35506.,
      37306., 39138., 41002., 15989.,  16841., 17709., 18593., 35354., 37122.,
      38922., 40754., 58223., 60971.,  63767., 66611., 60983., 63827., 66719.,
      69659., 44586., 46546., 48538.,  50562., 24301., 25313., 26341., 27385.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12856.,   19064.,   25784.,   33016.,   36116.,   46964.,   58580.,
      70964.,   52436.,   64820.,   77972.,   91892.,   68756.,   82676.,
      97364.,   112820.,  85076.,   100532.,  116756.,  133748.,  79544.,
      90872.,   102712.,  115064.,  74292.,   90516.,   107508.,  125268.,
      157422.,  184062.,  211854.,  240798.,  195726.,  224670.,  254766.,
      286014.,  234030.,  265278.,  297678.,  331230.,  272334.,  305886.,
      340590.,  376446.,  229620.,  253524.,  278196.,  303636.,  209076.,
      234516.,  260724.,  287700.,  387246.,  427710.,  469326.,  512094.,
      425550.,  468318.,  512238.,  557310.,  463854.,  508926.,  555150.,
      602526.,  502158.,  549534.,  598062.,  647742.,  401268.,  434388.,
      468276.,  502932.,  311224.,  332792.,  354872.,  377464.,  529748.,
      563636.,  598292.,  633716.,  564500.,  599924.,  636116.,  673076.,
      599252.,  636212.,  673940.,  712436.,  634004.,  672500.,  711764.,
      751796.,  476216.,  502904.,  530104.,  557816.,  224824.,  255608.,
      286904.,  318712.,  427796.,  475508.,  523988.,  573236.,  444116.,
      493364.,  543380.,  594164.,  460436.,  511220.,  562772.,  615092.,
      476756.,  529076.,  582164.,  636020.,  389816.,  425720.,  462136.,
      499064.,  613428.,  666516.,  720372.,  774996.,  1076718., 1158654.,
      1241742., 1325982., 1115022., 1199262., 1284654., 1371198., 1153326.,
      1239870., 1327566., 1416414., 1191630., 1280478., 1370478., 1461630.,
      916212.,  976980.,  1038516., 1100820., 748212.,  810516.,  873588.,
      937428.,  1306542., 1402302., 1499214., 1597278., 1344846., 1442910.,
      1542126., 1642494., 1383150., 1483518., 1585038., 1687710., 1421454.,
      1524126., 1627950., 1732926., 1087860., 1157844., 1228596., 1300116.,
      818104.,  864248.,  910904.,  958072.,  1363796., 1434548., 1506068.,
      1578356., 1398548., 1470836., 1543892., 1617716., 1433300., 1507124.,
      1581716., 1657076., 1468052., 1543412., 1619540., 1696436., 1081400.,
      1132664., 1184440., 1236728., 436792.,  492152.,  548024.,  604408.,
      819476.,  904052.,  989396.,  1075508., 835796.,  921908.,  1008788.,
      1096436., 852116.,  939764.,  1028180., 1117364., 868436.,  957620.,
      1047572., 1138292., 700088.,  760568.,  821560.,  883064.,  1152564.,
      1242516., 1333236., 1424724., 1996014., 2133246., 2271630., 2411166.,
      2034318., 2173854., 2314542., 2456382., 2072622., 2214462., 2357454.,
      2501598., 2110926., 2255070., 2400366., 2546814., 1602804., 1700436.,
      1798836., 1898004., 1287348., 1386516., 1486452., 1587156., 2225838.,
      2376894., 2529102., 2682462., 2264142., 2417502., 2572014., 2727678.,
      2302446., 2458110., 2614926., 2772894., 2340750., 2498718., 2657838.,
      2818110., 1774452., 1881300., 1988916., 2097300., 1324984., 1395704.,
      1466936., 1538680., 2197844., 2305460., 2413844., 2522996., 2232596.,
      2341748., 2451668., 2562356., 2267348., 2378036., 2489492., 2601716.,
      2302100., 2414324., 2527316., 2641076., 1686584., 1762424., 1838776.,
      1915640.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      2074.,   4042.,   6394.,   9130.,   5626.,   8362.,   11482.,  14986.,
      8508.,   10844.,  13436.,  16284.,  6974.,   8398.,   9950.,   11630.,
      1180.,   3260.,   5596.,   8188.,   10168.,  15352.,  21048.,  27256.,
      29012.,  38324.,  48404.,  59252.,  45332.,  56180.,  67796.,  80180.,
      46904.,  55160.,  63928.,  73208.,  32476.,  37116.,  42012.,  47164.,
      14428.,  18044.,  21916.,  26044.,  42808.,  51064.,  59832.,  69112.,
      87188.,  101108., 115796., 131252., 121940., 137396., 153620., 170612.,
      104120., 115448., 127288., 139640., 64156.,  70332.,  76764.,  83452.,
      26206.,  28910.,  31742.,  34702.,  62972.,  68892.,  75068.,  81500.,
      111322., 120970., 131002., 141418., 133306., 143722., 154522., 165706.,
      103868., 111324., 119036., 127004., 59774.,  63758.,  67870.,  72110.,
      1310.,   3502.,   5822.,   8270.,   11132.,  16028.,  21180.,  26588.,
      30490.,  38602.,  47098.,  55978.,  34042.,  42922.,  52186.,  61834.,
      35644.,  42076.,  48764.,  55708.,  24638.,  28110.,  31710.,  35438.,
      28316.,  34492.,  40924.,  47612.,  80824.,  94200.,  108088., 122488.,
      159572., 181172., 203540., 226676., 175892., 199028., 222932., 247604.,
      150328., 166776., 183736., 201208., 92380.,  101116., 110108., 119356.,
      90716.,  98428.,  106396., 114620., 211768., 228216., 245176., 262648.,
      365204., 391412., 418388., 446132., 399956., 427700., 456212., 485492.,
      305848., 325368., 345400., 365944., 173212., 183484., 194012., 204796.,
      76638.,  81390.,  86270.,  91278.,  172028., 182044., 192316., 202844.,
      287194., 302986., 319162., 335722., 309178., 325738., 342682., 360010.,
      229308., 240860., 252668., 264732., 126590., 132622., 138782., 145070.,
      2590.,   6830.,   11198.,  15694.,  21884.,  30876.,  40124.,  49628.,
      58906.,  73162.,  87802.,  102826., 62458.,  77482.,  92890.,  108682.,
      62780.,  73308.,  84092.,  95132.,  42302.,  47822.,  53470.,  59246.,
      55452.,  65724.,  76252.,  87036.,  151480., 173048., 195128., 217720.,
      290132., 324020., 358676., 394100., 306452., 341876., 378068., 415028.,
      253752., 278392., 303544., 329208., 152284., 165116., 178204., 191548.,
      167004., 178812., 190876., 203196., 380728., 405368., 430520., 456184.,
      643220., 681716., 720980., 761012., 677972., 718004., 758804., 800372.,
      507576., 535288., 563512., 592248., 282268., 296636., 311260., 326140.,
      127070., 133870., 140798., 147854., 281084., 295196., 309564., 324188.,
      463066., 485002., 507322., 530026., 485050., 507754., 530842., 554314.,
      354748., 370396., 386300., 402460., 193406., 201486., 209694., 218030.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,   62.,   83.,   75.,   99.,   192.,  237.,  198.,  207.,  372.,
      417.,  330.,  315.,  552.,  597.,  462.,  359.,  602.,  641.,  477.,
      269.,  482.,  503.,  395.,  639.,  1092., 1137., 858.,  747.,  1272.,
      1317., 990.,  855.,  1452., 1497., 1122., 839.,  1382., 1421., 1037.,
      509.,  902.,  923.,  715.,  1179., 1992., 2037., 1518., 1287., 2172.,
      2217., 1650., 1395., 2352., 2397., 1782., 1319., 2162., 2201., 1597.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   7.,   6.,   7.,   23.,  33.,  24.,  24.,  69.,  90.,  60.,
      41.,  101., 119., 72.,  35.,  82.,  93.,  54.,  7.,   22.,  37.,  24.,
      37.,  95.,  129., 78.,  96.,  231., 288., 168., 107., 245., 287., 162.,
      77.,  172., 195., 108., 13.,  40.,  67.,  42.,  67.,  167., 225., 132.,
      168., 393., 486., 276., 173., 389., 455., 252., 119., 262., 297., 162.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,   412.,   568.,   528.,   678.,   1347.,  1689.,  1434.,  1494.,
      2715.,  3057.,  2442.,  2310.,  4083.,  4425.,  3450.,  2704.,  4552.,
      4852.,  3624.,  1944.,  3532.,  3688.,  2928.,  4758.,  8187.,  8529.,
      6474.,  5574.,  9555.,  9897.,  7482.,  6390.,  10923., 11265., 8490.,
      6384.,  10552., 10852., 7944.,  3704.,  6652.,  6808.,  5328.,  8838.,
      15027., 15369., 11514., 9654.,  16395., 16737., 12522., 10470., 17763.,
      18105., 13530., 10064., 16552., 16852., 12264.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   42.,   39.,   40.,   144.,  216.,  164.,  153.,  462.,
      618.,  423.,  292.,  728.,  864.,  528.,  257.,  606.,  690.,  403.,
      41.,   142.,  258.,  171.,  256.,  672.,  936.,  572.,  693.,  1686.,
      2130., 1251., 796.,  1832., 2160., 1224., 581.,  1302., 1482., 823.,
      77.,   262.,  474.,  303.,  472.,  1200., 1656., 980.,  1233., 2910.,
      3642., 2079., 1300., 2936., 3456., 1920., 905.,  1998., 2274., 1243.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,  2972.,   4172.,   3944.,  4980.,  10038.,  12702.,  10884.,
      11316., 20694.,  23358.,  18756., 17652., 31350.,  34014.,  26628.,
      20968., 35372.,  37724.,  28232., 14728., 26972.,  28172.,  22504.,
      36660., 63318.,  65982.,  50244., 42996., 73974.,  76638.,  58116.,
      49332., 84630.,  87294.,  65988., 49768., 82412.,  84764.,  62152.,
      28168., 50972.,  52172.,  41064., 68340., 116598., 119262., 89604.,
      74676., 127254., 129918., 97476., 81012., 137910., 140574., 105348.,
      78568., 129452., 131804., 96072.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   284.,   278.,   260.,   1000.,  1544.,  1204.,  1074.,
      3348.,  4548.,  3162.,  2196.,  5512.,  6568.,  4036.,  1966.,  4652.,
      5308.,  3110.,  270.,   1004.,  1916.,  1286.,  1892.,  5032.,  7112.,
      4372.,  5250.,  12852., 16356., 9642.,  6132.,  14152., 16744., 9508.,
      4510.,  10124., 11548., 6422.,  510.,   1868.,  3548.,  2294.,  3524.,
      9064.,  12680., 7540.,  9426.,  22356., 28164., 16122., 10068., 22792.,
      26920., 14980., 7054.,  15596., 17788., 9734.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68.,   116.,  164.,  248.,  236.,  332.,  228.,  300.,  282.,  396.,
      579.,  768.,  741.,  948.,  642.,  792.,  666.,  828.,  1227., 1488.,
      1389., 1668., 1122., 1320., 1050., 1260., 1875., 2208., 2037., 2388.,
      1602., 1848., 1268., 1436., 2144., 2408., 2288., 2564., 1716., 1908.,
      868.,  1076., 1604., 1928., 1676., 2012., 1348., 1580., 2202., 2556.,
      3819., 4368., 3981., 4548., 3042., 3432., 2586., 2988., 4467., 5088.,
      4629., 5268., 3522., 3960., 2970., 3420., 5115., 5808., 5277., 5988.,
      4002., 4488., 3028., 3356., 5024., 5528., 5168., 5684., 3796., 4148.,
      1668., 2036., 3044., 3608., 3116., 3692., 2468., 2860., 4122., 4716.,
      7059., 7968., 7221., 8148., 5442., 6072., 4506., 5148., 7707., 8688.,
      7869., 8868., 5922., 6600., 4890., 5580., 8355., 9408., 8517., 9588.,
      6402., 7128., 4788., 5276., 7904., 8648., 8048., 8804., 5876., 6388.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    6.,   16.,   14.,  28.,   15.,   24.,   12.,   28.,
      52.,   92.,   84.,  132.,  68.,  96.,   57.,   96.,   186.,  276.,
      258.,  360.,  183., 240.,  128., 164.,  324.,  404.,  388.,  476.,
      240.,  288.,  117., 140.,  278., 328.,  318.,  372.,  187.,  216.,
      13.,   28.,   54.,  88.,   110., 148.,  75.,   96.,   108.,  148.,
      292.,  380.,  420., 516.,  260., 312.,  309.,  384.,  762.,  924.,
      978.,  1152., 579., 672.,  368., 428.,  852.,  980.,  1012., 1148.,
      576.,  648.,  273., 308.,  614., 688.,  702.,  780.,  391.,  432.,
      25.,   52.,   102., 160.,  206., 268.,  135.,  168.,  204.,  268.,
      532.,  668.,  756., 900.,  452., 528.,  561.,  672.,  1338., 1572.,
      1698., 1944., 975., 1104., 608., 692.,  1380., 1556., 1636., 1820.,
      912.,  1008., 429., 476.,  950., 1048., 1086., 1188., 595.,  648.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      460.,   828.,   1162.,  1810.,  1714.,  2458.,  1692.,  2252.,  2046.,
      2934.,  4281.,  5757.,  5541.,  7161.,  4854.,  6030.,  5022.,  6294.,
      9321.,  11373., 10581., 12777., 8598.,  10158., 7998.,  9654.,  14361.,
      16989., 15621., 18393., 12342., 14286., 9820.,  11148., 16642., 18730.,
      17770., 19954., 13356., 14876., 6540.,  8188.,  12202., 14770., 12754.,
      15418., 10332., 12172., 16926., 19734., 29481., 33837., 30741., 35241.,
      23574., 26670., 19902., 23094., 34521., 39453., 35781., 40857., 27318.,
      30798., 22878., 26454., 39561., 45069., 40821., 46473., 31062., 34926.,
      23580., 26188., 39202., 43210., 40330., 44434., 29676., 32476., 12620.,
      15548., 23242., 27730., 23794., 28378., 18972., 22092., 31806., 36534.,
      54681., 61917., 55941., 63321., 42294., 47310., 34782., 39894., 59721.,
      67533., 60981., 68937., 46038., 51438., 37758., 43254., 64761., 73149.,
      66021., 74553., 49782., 55566., 37340., 41228., 61762., 67690., 62890.,
      68914., 45996., 50076.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    34.,    106.,  90.,   194.,  105.,  173.,   70.,
      190.,   348.,   652.,   588.,  956.,  494.,  710.,  387.,   687.,
      1326.,  2022.,  1878.,  2670., 1359., 1803., 958.,  1238.,  2444.,
      3068.,  2940.,  3628.,  1830., 2206., 893.,  1073., 2130.,  2522.,
      2442.,  2866.,  1441.,  1669., 77.,   193.,  370.,  634.,   810.,
      1106.,  561.,   725.,   790.,  1102., 2172., 2860., 3180.,  3932.,
      1982.,  2390.,  2331.,  2919., 5790., 7062., 7494., 8862.,  4455.,
      5187.,  2830.,  3302.,  6572., 7580., 7836., 8908., 4470.,  5038.,
      2117.,  2393.,  4770.,  5354., 5466., 6082., 3049., 3373.,  149.,
      361.,   706.,   1162.,  1530., 2018., 1017., 1277., 1510.,  2014.,
      3996.,  5068.,  5772.,  6908., 3470., 4070., 4275., 5151.,  10254.,
      12102., 13110., 15054., 7551., 8571., 4702., 5366., 10700., 12092.,
      12732., 14188., 7110.,  7870., 3341., 3713., 7410., 8186.,  8490.,
      9298.,  4657.,  5077.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3352.,   6232.,   8708.,   13796.,  13028.,  18884.,  13016.,  17432.,
      15540.,  22548.,  32862.,  44526.,  42798.,  55614.,  37716.,  47028.,
      38964.,  49044.,  72606.,  88878.,  82542.,  99966.,  67284.,  79668.,
      62388.,  75540.,  112350., 133230., 122286., 144318., 96852.,  112308.,
      77272.,  87832.,  131108., 147716., 140036., 157412., 105368., 117464.,
      50712.,  63832.,  95108.,  115556., 99428.,  120644., 80856.,  95512.,
      132660., 155028., 231582., 266286., 241518., 277374., 185556., 210228.,
      156084., 181524., 271326., 310638., 281262., 321726., 215124., 242868.,
      179508., 208020., 311070., 354990., 321006., 366078., 244692., 275508.,
      186072., 206872., 309668., 341636., 318596., 351332., 234648., 256984.,
      98072.,  121432., 181508., 217316., 185828., 222404., 148696., 173592.,
      249780., 287508., 430302., 488046., 440238., 499134., 333396., 373428.,
      273204., 314004., 470046., 532398., 479982., 543486., 362964., 406068.,
      296628., 340500., 509790., 576750., 519726., 587838., 392532., 438708.,
      294872., 325912., 488228., 535556., 497156., 545252., 363928., 396504.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    220.,    764.,   636.,   1436.,  782.,   1310.,  460.,
      1388.,   2520.,   4888.,   4376.,  7256.,  3756.,  5452.,  2826.,  5178.,
      9972.,   15444.,  14292.,  20532., 10458., 13962., 7404.,  9612.,  18968.,
      23896.,  22872.,  28312.,  14284., 17260., 6974.,  8398.,  16668., 19772.,
      19132.,  22492.,  11310.,  13118., 510.,   1422.,  2716.,  4796.,  6204.,
      8540.,   4334.,   5630.,   6028.,  8492.,  16728., 22168., 24728., 30680.,
      15468.,  18700.,  18090.,  22746., 45108., 55188., 58644., 69492., 34938.,
      40746.,  22188.,  25932.,  51608., 59608., 61656., 70168., 35212., 39724.,
      16670.,  18862.,  37596.,  42236., 43132., 48028., 24078., 26654., 990.,
      2670.,   5212.,   8828.,   11772., 15644., 7886.,  9950.,  11596., 15596.,
      30936.,  39448.,  45080.,  54104., 27180., 31948., 33354., 40314., 80244.,
      94932.,  102996., 118452., 59418., 67530., 36972., 42252., 84248., 95320.,
      100440., 112024., 56140.,  62188., 26366., 29326., 58524., 64700., 67132.,
      73564.,  36846.,  40190.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      188.,   272.,   364.,   464.,   506.,   656.,   818.,   992.,   770.,
      944.,   1130.,  1328.,  780.,   912.,   1052.,  1200.,  918.,   1128.,
      1350.,  1584.,  1965.,  2316.,  2685.,  3072.,  2577.,  2964.,  3369.,
      3792.,  2286.,  2568.,  2862.,  3168.,  2358.,  2664.,  2982.,  3312.,
      4413.,  4908.,  5421.,  5952.,  5025.,  5556.,  6105.,  6672.,  4110.,
      4488.,  4878.,  5280.,  3798.,  4200.,  4614.,  5040.,  6861.,  7500.,
      8157.,  8832.,  7473.,  8148.,  8841.,  9552.,  5934.,  6408.,  6894.,
      7392.,  4748.,  5072.,  5404.,  5744.,  8066.,  8576.,  9098.,  9632.,
      8618.,  9152.,  9698.,  10256., 6492.,  6864.,  7244.,  7632.,  3068.,
      3472.,  3884.,  4304.,  5786.,  6416.,  7058.,  7712.,  6050.,  6704.,
      7370.,  8048.,  4940.,  5392.,  5852.,  6320.,  8118.,  8808.,  9510.,
      10224., 14205., 15276., 16365., 17472., 14817., 15924., 17049., 18192.,
      11406., 12168., 12942., 13728., 9558.,  10344., 11142., 11952., 16653.,
      17868., 19101., 20352., 17265., 18516., 19785., 21072., 13230., 14088.,
      14958., 15840., 10998., 11880., 12774., 13680., 19101., 20460., 21837.,
      23232., 19713., 21108., 22521., 23952., 15054., 16008., 16974., 17952.,
      11468., 12112., 12764., 13424., 19106., 20096., 21098., 22112., 19658.,
      20672., 21698., 22736., 14492., 15184., 15884., 16592., 5948.,  6672.,
      7404.,  8144.,  11066., 12176., 13298., 14432., 11330., 12464., 13610.,
      14768., 9100.,  9872.,  10652., 11440., 15318., 16488., 17670., 18864.,
      26445., 28236., 30045., 31872., 27057., 28884., 30729., 32592., 20526.,
      21768., 23022., 24288., 16758., 18024., 19302., 20592., 28893., 30828.,
      32781., 34752., 29505., 31476., 33465., 35472., 22350., 23688., 25038.,
      26400., 18198., 19560., 20934., 22320., 31341., 33420., 35517., 37632.,
      31953., 34068., 36201., 38352., 24174., 25608., 27054., 28512., 18188.,
      19152., 20124., 21104., 30146., 31616., 33098., 34592., 30698., 32192.,
      33698., 35216., 22492., 23504., 24524., 25552.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    9.,    16.,   10.,   24.,   42.,   64.,   34.,   56.,
      82.,   112.,  45.,   60.,   77.,   96.,   22.,   48.,   78.,   112.,
      140.,  208.,  284.,  368.,  252.,  336.,  428.,  528.,  222.,  272.,
      326.,  384.,  159.,  228.,  303.,  384.,  582.,  744.,  918.,  1104.,
      846.,  1032., 1230., 1440., 627.,  732.,  843.,  960.,  446.,  512.,
      582.,  656.,  1148., 1296., 1452., 1616., 1388., 1552., 1724., 1904.,
      870.,  960.,  1054., 1152., 425.,  468.,  513.,  560.,  1018., 1112.,
      1210., 1312., 1170., 1272., 1378., 1488., 693.,  748.,  805.,  864.,
      25.,   52.,   81.,   112.,  154.,  216.,  282.,  352.,  370.,  440.,
      514.,  592.,  261.,  300.,  341.,  384.,  358.,  432.,  510.,  592.,
      1004., 1168., 1340., 1520., 1500., 1680., 1868., 2064., 942.,  1040.,
      1142., 1248., 1095., 1236., 1383., 1536., 2742., 3048., 3366., 3696.,
      3582., 3912., 4254., 4608., 2139., 2316., 2499., 2688., 1358., 1472.,
      1590., 1712., 3164., 3408., 3660., 3920., 3788., 4048., 4316., 4592.,
      2166., 2304., 2446., 2592., 1025., 1092., 1161., 1232., 2314., 2456.,
      2602., 2752., 2658., 2808., 2962., 3120., 1485., 1564., 1645., 1728.,
      49.,   100.,  153.,  208.,  298.,  408.,  522.,  640.,  706.,  824.,
      946.,  1072., 477.,  540.,  605.,  672.,  694.,  816.,  942.,  1072.,
      1868., 2128., 2396., 2672., 2748., 3024., 3308., 3600., 1662., 1808.,
      1958., 2112., 2031., 2244., 2463., 2688., 4902., 5352., 5814., 6288.,
      6318., 6792., 7278., 7776., 3651., 3900., 4155., 4416., 2270., 2432.,
      2598., 2768., 5180., 5520., 5868., 6224., 6188., 6544., 6908., 7280.,
      3462., 3648., 3838., 4032., 1625., 1716., 1809., 1904., 3610., 3800.,
      3994., 4192., 4146., 4344., 4546., 4752., 2277., 2380., 2485., 2592.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1348.,   2004.,   2724.,   3508.,   3766.,   4942.,   6214.,   7582.,
      5830.,   7198.,   8662.,   10222.,  5988.,   7028.,   8132.,   9300.,
      6942.,   8598.,   10350.,  12198.,  15045.,  17817.,  20733.,  23793.,
      19869.,  22929.,  26133.,  29481.,  17742.,  19974.,  22302.,  24726.,
      18270.,  20694.,  23214.,  25830.,  34341.,  38265.,  42333.,  46545.,
      39165.,  43377.,  47733.,  52233.,  32142.,  35142.,  38238.,  41430.,
      29598.,  32790.,  36078.,  39462.,  53637.,  58713.,  63933.,  69297.,
      58461.,  63825.,  69333.,  74985.,  46542.,  50310.,  54174.,  58134.,
      37348.,  39924.,  42564.,  45268.,  63526.,  67582.,  71734.,  75982.,
      67894.,  72142.,  76486.,  80926.,  51204.,  54164.,  57188.,  60276.,
      23748.,  26964.,  30244.,  33588.,  45046.,  50062.,  55174.,  60382.,
      47110.,  52318.,  57622.,  63022.,  38628.,  42228.,  45892.,  49620.,
      63582.,  69078.,  74670.,  80358.,  111525., 120057., 128733., 137553.,
      116349., 125169., 134133., 143241., 89742.,  95814.,  101982., 108246.,
      74910.,  81174.,  87534.,  93990.,  130821., 140505., 150333., 160305.,
      135645., 145617., 155733., 165993., 104142., 110982., 117918., 124950.,
      86238.,  93270.,  100398., 107622., 150117., 160953., 171933., 183057.,
      154941., 166065., 177333., 188745., 118542., 126150., 133854., 141654.,
      90468.,  95604.,  100804., 106068., 150886., 158782., 166774., 174862.,
      155254., 163342., 171526., 179806., 114564., 120084., 125668., 131316.,
      46148.,  51924.,  57764.,  63668.,  86326.,  95182.,  104134., 113182.,
      88390.,  97438.,  106582., 115822., 71268.,  77428.,  83652.,  89940.,
      120222., 129558., 138990., 148518., 208005., 222297., 236733., 251313.,
      212829., 227409., 242133., 257001., 161742., 171654., 181662., 191766.,
      131550., 141654., 151854., 162150., 227301., 242745., 258333., 274065.,
      232125., 247857., 263733., 279753., 176142., 186822., 197598., 208470.,
      142878., 153750., 164718., 175782., 246597., 263193., 279933., 296817.,
      251421., 268305., 285333., 302505., 190542., 201990., 213534., 225174.,
      143588., 151284., 159044., 166868., 238246., 249982., 261814., 273742.,
      242614., 254542., 266566., 278686., 177924., 186004., 194148., 202356.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   234.,
      402.,   602.,   834.,   333.,   449.,   581.,   729.,   130.,   330.,
      562.,   826.,   996.,   1524.,  2116.,  2772.,  1860.,  2516.,  3236.,
      4020.,  1682.,  2074.,  2498.,  2954.,  1143.,  1683.,  2271.,  2907.,
      4350.,  5622.,  6990.,  8454.,  6414.,  7878.,  9438.,  11094., 4815.,
      5643.,  6519.,  7443.,  3442.,  3962.,  4514.,  5098.,  8900.,  10068.,
      11300., 12596., 10788., 12084., 13444., 14868., 6786.,  7498.,  8242.,
      9018.,  3317.,  3657.,  4013.,  4385.,  7962.,  8706.,  9482.,  10290.,
      9162.,  9970.,  10810., 11682., 5437.,  5873.,  6325.,  6793.,  149.,
      361.,   589.,   833.,   1114.,  1602.,  2122.,  2674.,  2826.,  3378.,
      3962.,  4578.,  2013.,  2321.,  2645.,  2985.,  2722.,  3306.,  3922.,
      4570.,  7716.,  9012.,  10372., 11796., 11652., 13076., 14564., 16116.,
      7346.,  8122.,  8930.,  9770.,  8487.,  9603.,  10767., 11979., 21342.,
      23766., 26286., 28902., 28014., 30630., 33342., 36150., 16767., 18171.,
      19623., 21123., 10642., 11546., 12482., 13450., 24836., 26772., 28772.,
      30836., 29796., 31860., 33988., 36180., 17058., 18154., 19282., 20442.,
      8069.,  8601.,  9149.,  9713.,  18234., 19362., 20522., 21714., 20970.,
      22162., 23386., 24642., 11725., 12353., 12997., 13657., 293.,   697.,
      1117.,  1553.,  2170.,  3042.,  3946.,  4882.,  5418.,  6354.,  7322.,
      8322.,  3693.,  4193.,  4709.,  5241.,  5314.,  6282.,  7282.,  8314.,
      14436., 16500., 18628., 20820., 21444., 23636., 25892., 28212., 13010.,
      14170., 15362., 16586., 15831., 17523., 19263., 21051., 38334., 41910.,
      45582., 49350., 49614., 53382., 57246., 61206., 28719., 30699., 32727.,
      34803., 17842., 19130., 20450., 21802., 40772., 43476., 46244., 49076.,
      48804., 51636., 54532., 57492., 27330., 28810., 30322., 31866., 12821.,
      13545., 14285., 15041., 28506., 30018., 31562., 33138., 32778., 34354.,
      35962., 37602., 18013., 18833., 19669., 20521.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10168.,   15352.,   21048.,   27256.,   29012.,   38324.,   48404.,
      59252.,   45332.,   56180.,   67796.,   80180.,   46904.,   55160.,
      63928.,   73208.,   53940.,   67092.,   81012.,   95700.,   117678.,
      139710.,  162894.,  187230.,  155982.,  180318.,  205806.,  232446.,
      139764.,  157524.,  176052.,  195348.,  143796.,  163092.,  183156.,
      203988.,  270894.,  302142.,  334542.,  368094.,  309198.,  342750.,
      377454.,  413310.,  254196.,  278100.,  302772.,  328212.,  233652.,
      259092.,  285300.,  312276.,  424110.,  464574.,  506190.,  548958.,
      462414.,  505182.,  549102.,  594174.,  368628.,  398676.,  429492.,
      461076.,  296248.,  316792.,  337848.,  359416.,  504212.,  536564.,
      569684.,  603572.,  538964.,  572852.,  607508.,  642932.,  406712.,
      430328.,  454456.,  479096.,  186808.,  212472.,  238648.,  265336.,
      355412.,  395444.,  436244.,  477812.,  371732.,  413300.,  455636.,
      498740.,  305464.,  334200.,  363448.,  393208.,  503220.,  547092.,
      591732.,  637140.,  883758.,  951870.,  1021134., 1091550., 922062.,
      992478.,  1064046., 1136766., 711924.,  760404.,  809652.,  859668.,
      593076.,  643092.,  693876.,  745428.,  1036974., 1114302., 1192782.,
      1272414., 1075278., 1154910., 1235694., 1317630., 826356.,  880980.,
      936372.,  992532.,  682932.,  739092.,  796020.,  853716.,  1190190.,
      1276734., 1364430., 1453278., 1228494., 1317342., 1407342., 1498494.,
      940788.,  1001556., 1063092., 1125396., 718648.,  759672.,  801208.,
      843256.,  1199252., 1262324., 1326164., 1390772., 1234004., 1298612.,
      1363988., 1430132., 911032.,  955128.,  999736.,  1044856., 363448.,
      409592.,  456248.,  503416.,  681812.,  752564.,  824084.,  896372.,
      698132.,  770420.,  843476.,  917300.,  564024.,  613240.,  662968.,
      713208.,  952500.,  1027092., 1102452., 1178580., 1649838., 1764030.,
      1879374., 1995870., 1688142., 1804638., 1922286., 2041086., 1284084.,
      1363284., 1443252., 1523988., 1042356., 1123092., 1204596., 1286868.,
      1803054., 1926462., 2051022., 2176734., 1841358., 1967070., 2093934.,
      2221950., 1398516., 1483860., 1569972., 1656852., 1132212., 1219092.,
      1306740., 1395156., 1956270., 2088894., 2222670., 2357598., 1994574.,
      2129502., 2265582., 2402814., 1512948., 1604436., 1696692., 1789716.,
      1141048., 1202552., 1264568., 1327096., 1894292., 1988084., 2082644.,
      2177972., 1929044., 2024372., 2120468., 2217332., 1415352., 1479928.,
      1545016., 1610616.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      1724.,   3036.,   4604.,   6428.,   2558.,   3470.,   4510.,   5678.,
      860.,    2428.,   4252.,   6332.,   7480.,   11640.,  16312.,  21496.,
      14264.,  19448.,  25144.,  31352.,  13084.,  16188.,  19548.,  23164.,
      8634.,   12906.,  17562.,  22602.,  33588.,  43668.,  54516.,  66132.,
      49908.,  61524.,  73908.,  87060.,  37722.,  44298.,  51258.,  58602.,
      27036.,  31164.,  35548.,  40188.,  70072.,  79352.,  89144.,  99448.,
      85048.,  95352.,  106168., 117496., 53596.,  59260.,  65180.,  71356.,
      26206.,  28910.,  31742.,  34702.,  62972.,  68892.,  75068.,  81500.,
      72508.,  78940.,  85628.,  92572.,  43070.,  46542.,  50142.,  53870.,
      990.,    2670.,   4478.,   6414.,   8444.,   12316.,  16444.,  20828.,
      22076.,  26460.,  31100.,  35996.,  15806.,  18254.,  20830.,  23534.,
      21212.,  25852.,  30748.,  35900.,  60472.,  70776.,  81592.,  92920.,
      91832.,  103160., 115000., 127352., 58012.,  64188.,  70620.,  77308.,
      66810.,  75690.,  84954.,  94602.,  168372., 187668., 207732., 228564.,
      221556., 242388., 263988., 286356., 132762., 143946., 155514., 167466.,
      84252.,  91452.,  98908.,  106620., 196792., 212216., 228152., 244600.,
      236344., 252792., 269752., 287224., 135388., 144124., 153116., 162364.,
      64030.,  68270.,  72638.,  77134.,  144764., 153756., 163004., 172508.,
      166588., 176092., 185852., 195868., 93182.,  98190.,  103326., 108590.,
      1950.,   5166.,   8510.,   11982.,  16508.,  23452.,  30652.,  38108.,
      42428.,  49884.,  57596.,  65564.,  29054.,  33038.,  37150.,  41390.,
      41564.,  49276.,  57244.,  65468.,  113464., 129912., 146872., 164344.,
      169400., 186872., 204856., 223352., 102940., 112188., 121692., 131452.,
      124986., 138474., 152346., 166602., 303156., 331668., 360948., 390996.,
      393204., 423252., 454068., 485652., 227802., 243594., 259770., 276330.,
      141468., 151740., 162268., 173052., 323512., 345080., 367160., 389752.,
      387640., 410232., 433336., 456952., 217180., 228988., 241052., 253372.,
      101854., 107630., 113534., 119566., 226556., 238620., 250940., 263516.,
      260668., 273244., 286076., 299164., 143294., 149838., 156510., 163310.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,   68.,   89.,   110.,  96.,   114.,  219.,  264.,  309.,  252.,
      249.,  444.,  489.,  534.,  417.,  384.,  669.,  714.,  759.,  582.,
      440.,  734.,  773.,  812.,  600.,  332.,  593.,  614.,  635.,  496.,
      789.,  1344., 1389., 1434., 1077., 924.,  1569., 1614., 1659., 1242.,
      1059., 1794., 1839., 1884., 1407., 1040., 1709., 1748., 1787., 1300.,
      632.,  1118., 1139., 1160., 896.,  1464., 2469., 2514., 2559., 1902.,
      1599., 2694., 2739., 2784., 2067., 1734., 2919., 2964., 3009., 2232.,
      1640., 2684., 2723., 2762., 2000.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,  12.,  9.,   8.,   26.,  56.,  54.,  36.,  30.,
      84.,  165., 144., 90.,  56.,  134., 236., 186., 108., 49.,  112.,
      190., 144., 81.,  10.,  31.,  64.,  57.,  36.,  53.,  134., 245.,
      198., 117., 138., 327., 570., 441., 252., 155., 350., 587., 438.,
      243., 112., 247., 406., 297., 162., 19.,  58.,  118., 102., 63.,
      98.,  242., 434., 342., 198., 246., 570., 975., 738., 414., 254.,
      566., 938., 690., 378., 175., 382., 622., 450., 243.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,   454.,   610.,   766.,   684.,   786.,   1545.,  1887.,  2229.,
      1842.,  1806.,  3255.,  3597.,  3939.,  3102.,  2826.,  4965.,  5307.,
      5649.,  4362.,  3324.,  5566.,  5866.,  6166.,  4572.,  2404.,  4354.,
      4510.,  4666.,  3684.,  5886.,  10095., 10437., 10779., 8142.,  6906.,
      11805., 12147., 12489., 9402.,  7926.,  13515., 13857., 14199., 10662.,
      7924.,  13066., 13366., 13666., 9972.,  4604.,  8254.,  8410.,  8566.,
      6684.,  10986., 18645., 18987., 19329., 14442., 12006., 20355., 20697.,
      21039., 15702., 13026., 22065., 22407., 22749., 16962., 12524., 20566.,
      20866., 21166., 15372.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   78.,   61.,   46.,   164.,  370.,  372.,  254.,
      195.,  570.,  1149., 1026., 651.,  406.,  980.,  1738., 1380., 806.,
      365.,  838.,  1427., 1086., 613.,  59.,   202.,  437.,  402.,  259.,
      370.,  956.,  1774., 1452., 866.,  1005., 2406., 4227., 3294., 1893.,
      1162., 2636., 4438., 3324., 1850., 851.,  1882., 3101., 2274., 1243.,
      113.,  382.,  815.,  726.,  457.,  694.,  1748., 3178., 2532., 1478.,
      1815., 4242., 7305., 5562., 3135., 1918., 4292., 7138., 5268., 2894.,
      1337., 2926., 4775., 3462., 1873.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,   3284.,   4484.,   5684.,   5144.,   5796.,   11550.,  14214.,
      16878.,  14052.,  13716.,  24870.,  27534.,  30198.,  23892.,  21636.,
      38190.,  40854.,  43518.,  33732.,  25816.,  43316.,  45668.,  48020.,
      35672.,  18232.,  33284.,  34484.,  35684.,  28344.,  45396.,  78150.,
      80814.,  83478.,  63252.,  53316.,  91470.,  94134.,  96798.,  73092.,
      61236.,  104790., 107454., 110118., 82932.,  61816.,  102116., 104468.,
      106820., 78072.,  35032.,  63284.,  64484.,  65684.,  51544.,  84996.,
      144750., 147414., 150078., 112452., 92916.,  158070., 160734., 163398.,
      122292., 100836., 171390., 174054., 176718., 132132., 97816.,  160916.,
      163268., 165620., 120472.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   556.,   446.,   300.,   1144.,  2660.,  2744.,
      1900.,  1386.,  4164.,  8526.,  7716.,  4938.,  3084.,  7480.,  13316.,
      10616., 6220.,  2814.,  6476.,  11050., 8428.,  4766.,  390.,   1436.,
      3202.,  3004.,  1958.,  2748.,  7192.,  13460., 11096., 6652.,  7650.,
      18420., 32502., 25428., 14658., 8988.,  20440., 34484., 25880., 14428.,
      6630.,  14684., 24226., 17788., 9734.,  750.,   2732.,  6010.,  5452.,
      3470.,  5196.,  13240., 24260., 19448., 11404., 13914., 32676., 56478.,
      43140., 24378., 14892., 33400., 55652., 41144., 22636., 10446., 22892.,
      37402., 27148., 14702.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76.,    128.,   182.,   272.,   254.,  356.,  326.,   440.,   300.,
      384.,   330.,   456.,   669.,   876.,  831.,  1056.,  993.,   1236.,
      834.,   1008.,  810.,   996.,   1479., 1776., 1641.,  1956.,  1803.,
      2136.,  1434.,  1668.,  1290.,  1536., 2289., 2676.,  2451.,  2856.,
      2613.,  3036.,  2034.,  2328.,  1564., 1760., 2630.,  2936.,  2774.,
      3092.,  2918.,  3248.,  2172.,  2400., 1076., 1328.,  1982.,  2372.,
      2054.,  2456.,  2126.,  2540.,  1700., 1984., 2730.,  3156.,  4719.,
      5376.,  4881.,  5556.,  5043.,  5736., 3834., 4308.,  3210.,  3696.,
      5529.,  6276.,  5691.,  6456.,  5853., 6636., 4434.,  4968.,  3690.,
      4236.,  6339.,  7176.,  6501.,  7356., 6663., 7536.,  5034.,  5628.,
      3764.,  4160.,  6230.,  6836.,  6374., 6992., 6518.,  7148.,  4772.,
      5200.,  2076.,  2528.,  3782.,  4472., 3854., 4556.,  3926.,  4640.,
      3100.,  3584.,  5130.,  5856.,  8769., 9876., 8931.,  10056., 9093.,
      10236., 6834.,  7608.,  5610.,  6396., 9579., 10776., 9741.,  10956.,
      9903.,  11136., 7434.,  8268.,  6090., 6936., 10389., 11676., 10551.,
      11856., 10713., 12036., 8034.,  8928., 5964., 6560.,  9830.,  10736.,
      9974.,  10892., 10118., 11048., 7372., 8000.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,    6.,    16.,   19.,   40.,   30.,   48.,   25.,   36.,
      14.,  32.,   60.,   104.,  146.,  224.,  156.,  216.,  110.,  144.,
      75.,  120.,  234.,  336.,  489.,  660.,  450.,  576.,  291.,  360.,
      182., 224.,  444.,  536.,  794.,  944.,  636.,  744.,  374.,  432.,
      169., 196.,  390.,  448.,  667.,  760.,  510.,  576.,  289.,  324.,
      19.,  40.,   78.,   124.,  181.,  256.,  174.,  228.,  115.,  144.,
      158., 212.,  420.,  536.,  794.,  980.,  660.,  792.,  398.,  468.,
      453., 552.,  1098., 1308., 1947., 2280., 1530., 1764., 885.,  1008.,
      542., 620.,  1236., 1400., 2090., 2348., 1572., 1752., 878.,  972.,
      403., 448.,  894.,  988.,  1477., 1624., 1086., 1188., 595.,  648.,
      37.,  76.,   150.,  232.,  343.,  472.,  318.,  408.,  205.,  252.,
      302., 392.,  780.,  968.,  1442., 1736., 1164., 1368., 686.,  792.,
      831., 984.,  1962., 2280., 3405., 3900., 2610., 2952., 1479., 1656.,
      902., 1016., 2028., 2264., 3386., 3752., 2508., 2760., 1382., 1512.,
      637., 700.,  1398., 1528., 2287., 2488., 1662., 1800., 901.,  972.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      516.,   916.,   1294.,  1990.,  1846.,  2638.,  2398.,  3286.,  2244.,
      2900.,  2406.,  3390.,  4965.,  6585.,  6225.,  7989.,  7485.,  9393.,
      6342.,  7710.,  6126.,  7590.,  11265., 13605., 12525., 15009., 13785.,
      16413., 11022., 12870., 9846.,  11790., 17565., 20625., 18825., 22029.,
      20085., 23433., 15702., 18030., 12132., 13684., 20446., 22870., 21574.,
      24094., 22702., 25318., 16932., 18740., 8116.,  10116., 15094., 18190.,
      15646., 18838., 16198., 19486., 13044., 15300., 21006., 24390., 36465.,
      41685., 37725., 43089., 38985., 44493., 29742., 33510., 24726., 28590.,
      42765., 48705., 44025., 50109., 45285., 51513., 34422., 38670., 28446.,
      32790., 49065., 55725., 50325., 57129., 51585., 58533., 39102., 43830.,
      29332., 32484., 48646., 53470., 49774., 54694., 50902., 55918., 37332.,
      40740., 15716., 19316., 28894., 34390., 29446., 35038., 29998., 35686.,
      23844., 27700., 39606., 45390., 67965., 76785., 69225., 78189., 70485.,
      79593., 53142., 59310., 43326., 49590., 74265., 83805., 75525., 85209.,
      76785., 86613., 57822., 64470., 47046., 53790., 80565., 90825., 81825.,
      92229., 83085., 93633., 62502., 69630., 46532., 51284., 76846., 84070.,
      77974., 85294., 79102., 86518., 57732., 62740.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    34.,    106.,   119.,   275.,   210.,   346.,   181.,
      265.,   82.,    218.,   404.,   740.,   1030.,  1630.,  1140.,  1604.,
      818.,   1082.,  519.,   867.,   1686.,  2478.,  3597.,  4929.,  3366.,
      4350.,  2199.,  2739.,  1378.,  1706.,  3380.,  4100.,  6070.,  7246.,
      4884.,  5732.,  2882.,  3338.,  1301.,  1513.,  3010.,  3466.,  5159.,
      5891.,  3954.,  4474.,  2245.,  2521.,  113.,   277.,   538.,   898.,
      1307.,  1895.,  1290.,  1714.,  865.,   1093.,  1162.,  1586.,  3140.,
      4052.,  5998.,  7462.,  5028.,  6068.,  3050.,  3602.,  3435.,  4215.,
      8382.,  10038., 14937., 17565., 11790., 13638., 6843.,  7815.,  4186.,
      4802.,  9572.,  10868., 16222., 18262., 12228., 13652., 6842.,  7586.,
      3137.,  3493.,  6970.,  7714.,  11531., 12695., 8490.,  9298.,  4657.,
      5077.,  221.,   529.,   1042.,  1690.,  2495.,  3515.,  2370.,  3082.,
      1549.,  1921.,  2242.,  2954.,  5876.,  7364.,  10966., 13294., 8916.,
      10532., 5282.,  6122.,  6351.,  7563.,  15078., 17598., 26277., 30201.,
      20214., 22926., 11487., 12891., 6994.,  7898.,  15764., 17636., 26374.,
      29278., 19572., 21572., 10802., 11834., 4973.,  5473.,  10930., 11962.,
      17903., 19499., 13026., 14122., 7069.,  7633.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3768.,   6904.,   9716.,   15188.,  14036.,  20276.,  18356.,  25364.,
      17336.,  22520.,  18324.,  26100.,  38190.,  51006.,  48126.,  62094.,
      58062.,  73182.,  49428.,  60276.,  47604.,  59220.,  87870.,  106446.,
      97806.,  117534., 107742., 128622., 86388.,  101076., 76884.,  92340.,
      137550., 161886., 147486., 172974., 157422., 184062., 123348., 141876.,
      95544.,  107896., 161204., 180500., 170132., 190196., 179060., 199892.,
      133688., 148088., 62968.,  78904.,  117716., 142388., 122036., 147476.,
      126356., 152564., 102136., 120120., 164724., 191700., 286590., 328206.,
      296526., 339294., 306462., 350382., 234228., 264276., 194004., 224820.,
      336270., 383646., 346206., 394734., 356142., 405822., 271188., 305076.,
      223284., 257940., 385950., 439086., 395886., 450174., 405822., 461262.,
      308148., 345876., 231544., 256696., 384404., 422900., 393332., 432596.,
      402260., 442292., 295288., 322488., 122168., 150904., 225716., 269588.,
      230036., 274676., 234356., 279764., 186936., 217720., 311124., 357300.,
      534990., 605406., 544926., 616494., 554862., 627582., 419028., 468276.,
      340404., 390420., 584670., 660846., 594606., 671934., 604542., 683022.,
      455988., 509076., 369684., 423540., 634350., 716286., 644286., 727374.,
      654222., 738462., 492948., 549876., 367544., 405496., 607604., 665300.,
      616532., 674996., 625460., 684692., 456888., 496888.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    220.,    764.,    826.,    2026.,   1564.,   2620.,
      1374.,   2030.,   540.,    1596.,   2936.,   5560.,   7700.,   12404.,
      8696.,   12344.,  6300.,   8380.,   3834.,   6570.,   12756.,  18996.,
      27534.,  38046.,  26004.,  33780.,  17082.,  21354.,  10716.,  13308.,
      26360.,  32056.,  47444.,  56756.,  38264.,  44984.,  22620.,  26236.,
      10206.,  11886.,  23644.,  27260.,  40570.,  46378.,  31132.,  35260.,
      17694.,  19886.,  750.,    2046.,   3964.,   6812.,   9898.,   14554.,
      9916.,   13276.,  6702.,   8510.,   8892.,   12252.,  24248.,  31480.,
      46580.,  58196.,  39224.,  47480.,  23868.,  28252.,  26730.,  32922.,
      65460.,  78612.,  116958., 137838., 92532.,  107220., 53802.,  61530.,
      32892.,  37788.,  75320.,  85624.,  127796., 144020., 96440.,  107768.,
      54012.,  59932.,  24750.,  27582.,  55036.,  60956.,  91114.,  100378.,
      67132.,  73564.,  36846.,  40190.,  1470.,   3918.,   7708.,   12860.,
      18970.,  27082.,  18268.,  23932.,  12030.,  14990.,  17244.,  22908.,
      45560.,  57400.,  85460.,  103988., 69752.,  82616.,  41436.,  48124.,
      49626.,  59274.,  118164., 138228., 206382., 237630., 159060., 180660.,
      90522.,  101706., 55068.,  62268.,  124280., 139192., 208148., 231284.,
      154616., 170552., 85404.,  93628.,  39294.,  43278.,  86428.,  94652.,
      141658., 154378., 103132., 111868., 55998.,  60494.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      212.,   304.,   404.,   512.,   566.,   728.,   902.,   1088.,  830.,
      1016.,  1214.,  1424.,  1094.,  1304.,  1526.,  1760.,  1044.,  1200.,
      1364.,  1536.,  1086.,  1320.,  1566.,  1824.,  2289.,  2676.,  3081.,
      3504.,  2901.,  3324.,  3765.,  4224.,  3513.,  3972.,  4449.,  4944.,
      3006.,  3336.,  3678.,  4032.,  2886.,  3240.,  3606.,  3984.,  5349.,
      5916.,  6501.,  7104.,  5961.,  6564.,  7185.,  7824.,  6573.,  7212.,
      7869.,  8544.,  5286.,  5736.,  6198.,  6672.,  4686.,  5160.,  5646.,
      6144.,  8409.,  9156.,  9921.,  10704., 9021.,  9804.,  10605., 11424.,
      9633.,  10452., 11289., 12144., 7566.,  8136.,  8718.,  9312.,  5876.,
      6256.,  6644.,  7040.,  9926.,  10520., 11126., 11744., 10478., 11096.,
      11726., 12368., 11030., 11672., 12326., 12992., 8244.,  8688.,  9140.,
      9600.,  3812.,  4304.,  4804.,  5312.,  7166.,  7928.,  8702.,  9488.,
      7430.,  8216.,  9014.,  9824.,  7694.,  8504.,  9326.,  10160., 6244.,
      6800.,  7364.,  7936.,  10086., 10920., 11766., 12624., 17589., 18876.,
      20181., 21504., 18201., 19524., 20865., 22224., 18813., 20172., 21549.,
      22944., 14406., 15336., 16278., 17232., 11886., 12840., 13806., 14784.,
      20649., 22116., 23601., 25104., 21261., 22764., 24285., 25824., 21873.,
      23412., 24969., 26544., 16686., 17736., 18798., 19872., 13686., 14760.,
      15846., 16944., 23709., 25356., 27021., 28704., 24321., 26004., 27705.,
      29424., 24933., 26652., 28389., 30144., 18966., 20136., 21318., 22512.,
      14276., 15056., 15844., 16640., 23726., 24920., 26126., 27344., 24278.,
      25496., 26726., 27968., 24830., 26072., 27326., 28592., 18244., 19088.,
      19940., 20800., 7412.,  8304.,  9204.,  10112., 13766., 15128., 16502.,
      17888., 14030., 15416., 16814., 18224., 14294., 15704., 17126., 18560.,
      11444., 12400., 13364., 14336., 19086., 20520., 21966., 23424., 32889.,
      35076., 37281., 39504., 33501., 35724., 37965., 40224., 34113., 36372.,
      38649., 40944., 25806., 27336., 28878., 30432., 20886., 22440., 24006.,
      25584., 35949., 38316., 40701., 43104., 36561., 38964., 41385., 43824.,
      37173., 39612., 42069., 44544., 28086., 29736., 31398., 33072., 22686.,
      24360., 26046., 27744., 39009., 41556., 44121., 46704., 39621., 42204.,
      44805., 47424., 40233., 42852., 45489., 48144., 30366., 32136., 33918.,
      35712., 22676., 23856., 25044., 26240., 37526., 39320., 41126., 42944.,
      38078., 39896., 41726., 43568., 38630., 40472., 42326., 44192., 28244.,
      29488., 30740., 32000.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,     4.,     9.,     16.,    10.,    24.,    42.,    64.,    43.,
      76.,    115.,   160.,   90.,    120.,   154.,   192.,   81.,    100.,
      121.,   144.,   26.,    56.,    90.,    128.,   164.,   240.,   324.,
      416.,   446.,   584.,   734.,   896.,   516.,   624.,   740.,   864.,
      378.,   440.,   506.,   576.,   219.,   300.,   387.,   480.,   750.,
      936.,   1134.,  1344.,  1641.,  1956.,  2289.,  2640.,  1566.,  1800.,
      2046.,  2304.,  1035.,  1164.,  1299.,  1440.,  650.,   728.,   810.,
      896.,   1604.,  1776.,  1956.,  2144.,  2894.,  3176.,  3470.,  3776.,
      2340.,  2544.,  2756.,  2976.,  1386.,  1496.,  1610.,  1728.,  625.,
      676.,   729.,   784.,   1450.,  1560.,  1674.,  1792.,  2491.,  2668.,
      2851.,  3040.,  1914.,  2040.,  2170.,  2304.,  1089.,  1156.,  1225.,
      1296.,  37.,    76.,    117.,   160.,   226.,   312.,   402.,   496.,
      583.,   724.,   871.,   1024.,  594.,   696.,   802.,   912.,   405.,
      460.,   517.,   576.,   530.,   632.,   738.,   848.,   1460.,  1680.,
      1908.,  2144.,  2822.,  3176.,  3542.,  3920.,  2388.,  2640.,  2900.,
      3168.,  1458.,  1592.,  1730.,  1872.,  1623.,  1812.,  2007.,  2208.,
      3990.,  4392.,  4806.,  5232.,  7149.,  7788.,  8445.,  9120.,  5670.,
      6120.,  6582.,  7056.,  3303.,  3540.,  3783.,  4032.,  2018.,  2168.,
      2322.,  2480.,  4628.,  4944.,  5268.,  5600.,  7862.,  8360.,  8870.,
      9392.,  5940.,  6288.,  6644.,  7008.,  3330.,  3512.,  3698.,  3888.,
      1525.,  1612.,  1701.,  1792.,  3394.,  3576.,  3762.,  3952.,  5623.,
      5908.,  6199.,  6496.,  4146.,  4344.,  4546.,  4752.,  2277.,  2380.,
      2485.,  2592.,  73.,    148.,   225.,   304.,   442.,   600.,   762.,
      928.,   1123.,  1372.,  1627.,  1888.,  1098.,  1272.,  1450.,  1632.,
      729.,   820.,   913.,   1008.,  1034.,  1208.,  1386.,  1568.,  2756.,
      3120.,  3492.,  3872.,  5198.,  5768.,  6350.,  6944.,  4260.,  4656.,
      5060.,  5472.,  2538.,  2744.,  2954.,  3168.,  3027.,  3324.,  3627.,
      3936.,  7230.,  7848.,  8478.,  9120.,  12657., 13620., 14601., 15600.,
      9774.,  10440., 11118., 11808., 5571.,  5916.,  6267.,  6624.,  3386.,
      3608.,  3834.,  4064.,  7652.,  8112.,  8580.,  9056.,  12830., 13544.,
      14270., 15008., 9540.,  10032., 10532., 11040., 5274.,  5528.,  5786.,
      6048.,  2425.,  2548.,  2673.,  2800.,  5338.,  5592.,  5850.,  6112.,
      8755.,  9148.,  9547.,  9952.,  6378.,  6648.,  6922.,  7200.,  3465.,
      3604.,  3745.,  3888.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1524.,   2244.,   3028.,   3876.,   4222.,   5494.,   6862.,   8326.,
      6286.,   7750.,   9310.,   10966.,  8350.,   10006.,  11758.,  13606.,
      8052.,   9284.,   10580.,  11940.,  8238.,   10086.,  12030.,  14070.,
      17565.,  20625.,  23829.,  27177.,  22389.,  25737.,  29229.,  32865.,
      27213.,  30849.,  34629.,  38553.,  23406.,  26022.,  28734.,  31542.,
      22398.,  25206.,  28110.,  31110.,  41685.,  46185.,  50829.,  55617.,
      46509.,  51297.,  56229.,  61305.,  51333.,  56409.,  61629.,  66993.,
      41406.,  44982.,  48654.,  52422.,  36558.,  40326.,  44190.,  48150.,
      65805.,  71745.,  77829.,  84057.,  70629.,  76857.,  83229.,  89745.,
      75453.,  81969.,  88629.,  95433.,  59406.,  63942.,  68574.,  73302.,
      46260.,  49284.,  52372.,  55524.,  78238.,  82966.,  87790.,  92710.,
      82606.,  87526.,  92542.,  97654.,  86974.,  92086.,  97294.,  102598.,
      65076.,  68612.,  72212.,  75876.,  29524.,  33444.,  37428.,  41476.,
      55822.,  61894.,  68062.,  74326.,  57886.,  64150.,  70510.,  76966.,
      59950.,  66406.,  72958.,  79606.,  48852.,  53284.,  57780.,  62340.,
      79038.,  85686.,  92430.,  99270.,  138165., 148425., 158829., 169377.,
      142989., 153537., 164229., 175065., 147813., 158649., 169629., 180753.,
      113406., 120822., 128334., 135942., 93198.,  100806., 108510., 116310.,
      162285., 173985., 185829., 197817., 167109., 179097., 191229., 203505.,
      171933., 184209., 196629., 209193., 131406., 139782., 148254., 156822.,
      107358., 115926., 124590., 133350., 186405., 199545., 212829., 226257.,
      191229., 204657., 218229., 231945., 196053., 209769., 223629., 237633.,
      149406., 158742., 168174., 177702., 112660., 118884., 125172., 131524.,
      187438., 196966., 206590., 216310., 191806., 201526., 211342., 221254.,
      196174., 206086., 216094., 226198., 144276., 151012., 157812., 164676.,
      57524.,  64644.,  71828.,  79076.,  107422., 118294., 129262., 140326.,
      109486., 120550., 131710., 142966., 111550., 122806., 134158., 145606.,
      89652.,  97284.,  104980., 112740., 149838., 161286., 172830., 184470.,
      258765., 276225., 293829., 311577., 263589., 281337., 299229., 317265.,
      268413., 286449., 304629., 322953., 203406., 215622., 227934., 240342.,
      163998., 176406., 188910., 201510., 282885., 301785., 320829., 340017.,
      287709., 306897., 326229., 345705., 292533., 312009., 331629., 351393.,
      221406., 234582., 247854., 261222., 178158., 191526., 204990., 218550.,
      307005., 327345., 347829., 368457., 311829., 332457., 353229., 374145.,
      316653., 337569., 358629., 379833., 239406., 253542., 267774., 282102.,
      179060., 188484., 197972., 207524., 296638., 310966., 325390., 339910.,
      301006., 315526., 330142., 344854., 305374., 320086., 334894., 349798.,
      223476., 233412., 243412., 253476.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,     61.,     113.,    58.,     162.,    298.,    466.,
      287.,   539.,    839.,    1187.,   666.,    898.,    1162.,   1458.,
      613.,   761.,    925.,    1105.,   154.,    386.,    650.,    946.,
      1172.,  1764.,   2420.,   3140.,   3310.,   4390.,   5566.,   6838.,
      3924.,  4772.,   5684.,   6660.,   2906.,   3394.,   3914.,   4466.,
      1599.,  2235.,   2919.,   3651.,   5646.,   7110.,   8670.,   10326.,
      12525., 15009.,  17637.,  20409.,  12078.,  13926.,  15870.,  17910.,
      8031.,  9051.,   10119.,  11235.,  5050.,   5666.,   6314.,   6994.,
      12500., 13860.,  15284.,  16772.,  22606.,  24838.,  27166.,  29590.,
      18324., 19940.,  21620.,  23364.,  10874.,  11746.,  12650.,  13586.,
      4901.,  5305.,   5725.,   6161.,   11386.,  12258.,  13162.,  14098.,
      19583., 20987.,  22439.,  23939.,  15066.,  16066.,  17098.,  18162.,
      8581.,  9113.,   9661.,   10225.,  221.,    529.,    853.,    1193.,
      1642.,  2322.,   3034.,   3778.,   4391.,   5507.,   6671.,   7883.,
      4554.,  5362.,   6202.,   7074.,   3133.,   3569.,   4021.,   4489.,
      4042.,  4850.,   5690.,   6562.,   11252.,  12996.,  14804.,  16676.,
      21886., 24694.,  27598.,  30598.,  18612.,  20612.,  22676.,  24804.,
      11402., 12466.,  13562.,  14690.,  12615.,  14115.,  15663.,  17259.,
      31134., 34326.,  37614.,  40998.,  55941.,  61017.,  66237.,  71601.,
      44478., 48054.,  51726.,  55494.,  25959.,  27843.,  29775.,  31755.,
      15850., 17042.,  18266.,  19522.,  36404.,  38916.,  41492.,  44132.,
      61918., 65878.,  69934.,  74086.,  46836.,  49604.,  52436.,  55332.,
      26282., 27730.,  29210.,  30722.,  12029.,  12721.,  13429.,  14153.,
      26794., 28242.,  29722.,  31234.,  44423.,  46691.,  49007.,  51371.,
      32778., 34354.,  35962.,  37602.,  18013.,  18833.,  19669.,  20521.,
      437.,   1033.,   1645.,   2273.,   3226.,   4482.,   5770.,   7090.,
      8495.,  10475.,  12503.,  14579.,  8442.,   9826.,   11242.,  12690.,
      5653.,  6377.,   7117.,   7873.,   7930.,   9314.,   10730.,  12178.,
      21332., 24228.,  27188.,  30212.,  40462.,  44998.,  49630.,  54358.,
      33300., 36452.,  39668.,  42948.,  19898.,  21538.,  23210.,  24914.,
      23631., 25995.,  28407.,  30867.,  56622.,  61542.,  66558.,  71670.,
      99357., 107025., 114837., 122793., 76878.,  82182.,  87582.,  93078.,
      43887., 46635.,  49431.,  52275.,  26650.,  28418.,  30218.,  32050.,
      60308., 63972.,  67700.,  71492.,  101230., 106918., 112702., 118582.,
      75348., 79268.,  83252.,  87300.,  41690.,  43714.,  45770.,  47858.,
      19157., 20137.,  21133.,  22145.,  42202.,  44226.,  46282.,  48370.,
      69263., 72395.,  75575.,  78803.,  50490.,  52642.,  54826.,  57042.,
      27445., 28553.,  29677.,  30817.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11512.,   17208.,   23416.,   30136.,   32564.,   42644.,   53492.,
      65108.,   48884.,   60500.,   72884.,   86036.,   65204.,   78356.,
      92276.,   106964.,  63224.,   73016.,   83320.,   94136.,   64116.,
      78804.,   94260.,   110484.,  137550.,  161886.,  187374.,  214014.,
      175854.,  202494.,  230286.,  259230.,  214158.,  243102.,  273198.,
      304446.,  184692.,  205524.,  227124.,  249492.,  176436.,  198804.,
      221940.,  245844.,  329070.,  364926.,  401934.,  440094.,  367374.,
      405534.,  444846.,  485310.,  405678.,  446142.,  487758.,  530526.,
      327732.,  356244.,  385524.,  415572.,  288756.,  318804.,  349620.,
      381204.,  520590.,  567966.,  616494.,  666174.,  558894.,  608574.,
      659406.,  711390.,  597198.,  649182.,  702318.,  756606.,  470772.,
      506964.,  543924.,  581652.,  367096.,  391224.,  415864.,  441016.,
      621236.,  658964.,  697460.,  736724.,  655988.,  695252.,  735284.,
      776084.,  690740.,  731540.,  773108.,  815444.,  517112.,  545336.,
      574072.,  603320.,  232312.,  263608.,  295416.,  327736.,  440564.,
      489044.,  538292.,  588308.,  456884.,  506900.,  557684.,  609236.,
      473204.,  524756.,  577076.,  630164.,  386424.,  421816.,  457720.,
      494136.,  625716.,  678804.,  732660.,  787284.,  1095150., 1177086.,
      1260174., 1344414., 1133454., 1217694., 1303086., 1389630., 1171758.,
      1258302., 1345998., 1434846., 899892.,  959124.,  1019124., 1079892.,
      738036.,  798804.,  860340.,  922644.,  1286670., 1380126., 1474734.,
      1570494., 1324974., 1420734., 1517646., 1615710., 1363278., 1461342.,
      1560558., 1660926., 1042932., 1109844., 1177524., 1245972., 850356.,
      918804.,  988020.,  1058004., 1478190., 1583166., 1689294., 1796574.,
      1516494., 1623774., 1732206., 1841790., 1554798., 1664382., 1775118.,
      1887006., 1185972., 1260564., 1335924., 1412052., 895096.,  944824.,
      995064.,  1045816., 1490036., 1566164., 1643060., 1720724., 1524788.,
      1602452., 1680884., 1760084., 1559540., 1638740., 1718708., 1799444.,
      1147512., 1201336., 1255672., 1310520., 453112.,  510008.,  567416.,
      625336.,  848564.,  935444.,  1023092., 1111508., 864884.,  953300.,
      1042484., 1132436., 881204.,  971156.,  1061876., 1153364., 709624.,
      770616.,  832120.,  894136.,  1187316., 1278804., 1371060., 1464084.,
      2052750., 2192286., 2332974., 2474814., 2091054., 2232894., 2375886.,
      2520030., 2129358., 2273502., 2418798., 2565246., 1615092., 1712724.,
      1811124., 1910292., 1299636., 1398804., 1498740., 1599444., 2244270.,
      2395326., 2547534., 2700894., 2282574., 2435934., 2590446., 2746110.,
      2320878., 2476542., 2633358., 2791326., 1758132., 1863444., 1969524.,
      2076372., 1411956., 1518804., 1626420., 1734804., 2435790., 2598366.,
      2762094., 2926974., 2474094., 2638974., 2805006., 2972190., 2512398.,
      2679582., 2847918., 3017406., 1901172., 2014164., 2127924., 2242452.,
      1423096., 1498424., 1574264., 1650616., 2358836., 2473364., 2588660.,
      2704724., 2393588., 2509652., 2626484., 2744084., 2428340., 2545940.,
      2664308., 2783444., 1777912., 1857336., 1937272., 2017720.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      2074.,   4042.,   6394.,   9130.,   5116.,   6940.,   9020.,   11356.,
      4766.,   5934.,   7230.,   8654.,   1020.,   2844.,   4924.,   7260.,
      8824.,   13496.,  18680.,  24376.,  25460.,  34004.,  43316.,  53396.,
      30584.,  37304.,  44536.,  52280.,  22780.,  26652.,  30780.,  35164.,
      12186.,  17226.,  22650.,  28458.,  43764.,  55380.,  67764.,  80916.,
      97806.,  117534., 138414., 160446., 94836.,  109524., 124980., 141204.,
      63258.,  71370.,  79866.,  88746.,  39804.,  44700.,  49852.,  55260.,
      98680.,  109496., 120824., 132664., 178676., 196436., 214964., 234260.,
      145016., 157880., 171256., 185144., 86140.,  93084.,  100284., 107740.,
      38814.,  42030.,  45374.,  48846.,  90236.,  97180.,  104380., 111836.,
      155290., 166474., 178042., 189994., 119548., 127516., 135740., 144220.,
      68126.,  72366.,  76734.,  81230.,  1470.,   3918.,   6494.,   9198.,
      12476.,  17884.,  23548.,  29468.,  34042.,  42922.,  52186.,  61834.,
      35644.,  42076.,  48764.,  55708.,  24638.,  28110.,  31710.,  35438.,
      31548.,  37980.,  44668.,  51612.,  88312.,  102200., 116600., 131512.,
      172340., 194708., 217844., 241748., 146936., 162872., 179320., 196280.,
      90172.,  98652.,  107388., 116380., 99450.,  111402., 123738., 136458.,
      245940., 271380., 297588., 324564., 442542., 483006., 524622., 567390.,
      352308., 380820., 410100., 440148., 205818., 220842., 236250., 252042.,
      125628., 135132., 144892., 154908., 288760., 308792., 329336., 350392.,
      491444., 523028., 555380., 588500., 371960., 394040., 416632., 439736.,
      208828., 220380., 232188., 244252., 95550.,  101070., 106718., 112494.,
      212924., 224476., 236284., 248348., 353146., 371242., 389722., 408586.,
      260668., 273244., 286076., 299164., 143294., 149838., 156510., 163310.,
      2910.,   7662.,   12542.,  17550.,  24572.,  34588.,  44860.,  55388.,
      66010.,  81802.,  97978.,  114538., 66172.,  77212.,  88508.,  100060.,
      44510.,  50286.,  56190.,  62222.,  62076.,  73116.,  84412.,  95964.,
      167800., 190904., 214520., 238648., 319220., 355412., 392372., 430100.,
      263288., 288440., 314104., 340280., 157564., 170652., 183996., 197596.,
      186714., 205578., 224826., 244458., 448116., 487380., 527412., 568212.,
      787278., 848478., 910830., 974334., 609780., 652116., 695220., 739092.,
      348378., 370314., 392634., 415338., 211452., 225564., 239932., 254556.,
      478840., 508088., 537848., 568120., 804212., 849620., 895796., 942740.,
      598904., 630200., 662008., 694328., 331516., 347676., 364092., 380764.,
      152286., 160110., 168062., 176142., 335612., 351772., 368188., 384860.,
      551002., 576010., 601402., 627178., 401788., 418972., 436412., 454108.,
      218462., 227310., 236286., 245390.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,   74.,   95.,   116.,  137.,  117.,  129.,  246.,  291.,  336.,
      381.,  306.,  291.,  516.,  561.,  606.,  651.,  504.,  453.,  786.,
      831.,  876.,  921.,  702.,  521.,  866.,  905.,  944.,  983.,  723.,
      395.,  704.,  725.,  746.,  767.,  597.,  939.,  1596., 1641., 1686.,
      1731., 1296., 1101., 1866., 1911., 1956., 2001., 1494., 1263., 2136.,
      2181., 2226., 2271., 1692., 1241., 2036., 2075., 2114., 2153., 1563.,
      755.,  1334., 1355., 1376., 1397., 1077., 1749., 2946., 2991., 3036.,
      3081., 2286., 1911., 3216., 3261., 3306., 3351., 2484., 2073., 3486.,
      3531., 3576., 3621., 2682., 1961., 3206., 3245., 3284., 3323., 2403.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    10.,  16.,  17.,   12.,   9.,   29.,  62.,  83.,
      75.,   48.,   36.,  99.,  192.,  237.,  198., 120., 71.,  167.,
      290.,  329.,  253., 144., 63.,   142.,  238., 262., 195., 108.,
      13.,   40.,   82.,  88.,  77.,   48.,   69.,  173., 314., 335.,
      267.,  156.,  180., 423., 732.,  777.,  594., 336., 203., 455.,
      758.,  797.,  589., 324., 147.,  322.,  526., 550., 399., 216.,
      25.,   76.,   154., 160., 137.,  84.,   129., 317., 566., 587.,
      459.,  264.,  324., 747., 1272., 1317., 990., 552., 335., 743.,
      1226., 1265., 925., 504., 231.,  502.,  814., 838., 603., 324.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,   496.,   652.,   808.,   964.,   840.,   894.,   1743.,  2085.,
      2427.,  2769.,  2250.,  2118.,  3795.,  4137.,  4479.,  4821.,  3762.,
      3342.,  5847.,  6189.,  6531.,  6873.,  5274.,  3944.,  6580.,  6880.,
      7180.,  7480.,  5520.,  2864.,  5176.,  5332.,  5488.,  5644.,  4440.,
      7014.,  12003., 12345., 12687., 13029., 9810.,  8238.,  14055., 14397.,
      14739., 15081., 11322., 9462.,  16107., 16449., 16791., 17133., 12834.,
      9464.,  15580., 15880., 16180., 16480., 12000., 5504.,  9856.,  10012.,
      10168., 10324., 8040.,  13134., 22263., 22605., 22947., 23289., 17370.,
      14358., 24315., 24657., 24999., 25341., 18882., 15582., 26367., 26709.,
      27051., 27393., 20394., 14984., 24580., 24880., 25180., 25480., 18480.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   101.,  114.,  83.,   52.,   184.,  412.,  568.,
      528.,  344.,  237.,  678.,  1347., 1689., 1434., 879.,  520.,  1232.,
      2152., 2452., 1896., 1084., 473.,  1070., 1799., 1985., 1482., 823.,
      77.,   262.,  563.,  605.,  546.,  347.,  484.,  1240., 2284., 2440.,
      1968., 1160., 1317., 3126., 5451., 5793., 4458., 2535., 1528., 3440.,
      5752., 6052., 4488., 2476., 1121., 2462., 4031., 4217., 3066., 1663.,
      149.,  502.,  1067., 1109., 978.,  611.,  916.,  2296., 4156., 4312.,
      3408., 1976., 2397., 5574., 9555., 9897., 7482., 4191., 2536., 5648.,
      9352., 9652., 7080., 3868., 1769., 3854., 6263., 6449., 4650., 2503.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,   3596.,   4796.,   5996.,   7196.,   6344.,   6612.,   13062.,
      15726.,  18390.,  21054.,  17220.,  16116.,  29046.,  31710.,  34374.,
      37038.,  29028.,  25620.,  45030.,  47694.,  50358.,  53022.,  40836.,
      30664.,  51260.,  53612.,  55964.,  58316.,  43112.,  21736.,  39596.,
      40796.,  41996.,  43196.,  34184.,  54132.,  92982.,  95646.,  98310.,
      100974., 76260.,  63636.,  108966., 111630., 114294., 116958., 88068.,
      73140.,  124950., 127614., 130278., 132942., 99876.,  73864.,  121820.,
      124172., 126524., 128876., 93992.,  41896.,  75596.,  76796.,  77996.,
      79196.,  62024.,  101652., 172902., 175566., 178230., 180894., 135300.,
      111156., 188886., 191550., 194214., 196878., 147108., 120660., 204870.,
      207534., 210198., 212862., 158916., 117064., 192380., 194732., 197084.,
      199436., 144872.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   706.,   828.,   614.,   340.,   1288.,  2972.,
      4172.,  3944.,  2596.,  1698.,  4980.,  10038., 12702., 10884., 6714.,
      3972.,  9448.,  16556., 18908., 14664., 8404.,  3662.,  8300.,  13978.,
      15442., 11548., 6422.,  510.,   1868.,  4138.,  4450.,  4092.,  2630.,
      3604.,  9352.,  17372., 18572., 15080., 8932.,  10050., 23988., 42006.,
      44670., 34500., 19674., 11844., 26728., 44780., 47132., 35016., 19348.,
      8750.,  19244., 31546., 33010., 24028., 13046., 990.,   3596.,  7882.,
      8194.,  7356.,  4646.,  6868.,  17416., 31772., 32972., 26216., 15268.,
      18402., 42996., 73974., 76638., 58116., 32634., 19716., 44008., 73004.,
      75356., 55368., 30292., 13838., 30188., 49114., 50578., 36508., 19670.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84.,    140.,   200.,   296.,   272.,   380.,   344.,   464.,   416.,
      548.,   372.,   468.,   378.,   516.,   759.,   984.,   921.,   1164.,
      1083.,  1344.,  1245.,  1524.,  1026.,  1224.,  954.,   1164.,  1731.,
      2064.,  1893.,  2244.,  2055.,  2424.,  2217.,  2604.,  1746.,  2016.,
      1530.,  1812.,  2703.,  3144.,  2865.,  3324.,  3027.,  3504.,  3189.,
      3684.,  2466.,  2808.,  1860.,  2084.,  3116.,  3464.,  3260.,  3620.,
      3404.,  3776.,  3548.,  3932.,  2628.,  2892.,  1284.,  1580.,  2360.,
      2816.,  2432.,  2900.,  2504.,  2984.,  2576.,  3068.,  2052.,  2388.,
      3258.,  3756.,  5619.,  6384.,  5781.,  6564.,  5943.,  6744.,  6105.,
      6924.,  4626.,  5184.,  3834.,  4404.,  6591.,  7464.,  6753.,  7644.,
      6915.,  7824.,  7077.,  8004.,  5346.,  5976.,  4410.,  5052.,  7563.,
      8544.,  7725.,  8724.,  7887.,  8904.,  8049.,  9084.,  6066.,  6768.,
      4500.,  4964.,  7436.,  8144.,  7580.,  8300.,  7724.,  8456.,  7868.,
      8612.,  5748.,  6252.,  2484.,  3020.,  4520.,  5336.,  4592.,  5420.,
      4664.,  5504.,  4736.,  5588.,  3732.,  4308.,  6138.,  6996.,  10479.,
      11784., 10641., 11964., 10803., 12144., 10965., 12324., 8226.,  9144.,
      6714.,  7644.,  11451., 12864., 11613., 13044., 11775., 13224., 11937.,
      13404., 8946.,  9936.,  7290.,  8292.,  12423., 13944., 12585., 14124.,
      12747., 14304., 12909., 14484., 9666.,  10728., 7140.,  7844.,  11756.,
      12824., 11900., 12980., 12044., 13136., 12188., 13292., 8868.,  9612.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    6.,    16.,   19.,   40.,   37.,   64.,   46.,   68.,
      35.,   48.,   16.,   36.,   68.,   116.,  164.,  248.,  236.,  332.,
      228.,  300.,  152.,  192.,  93.,   144.,  282.,  396.,  579.,  768.,
      741.,  948.,  642.,  792.,  399.,  480.,  236.,  284.,  564.,  668.,
      992.,  1160., 1136., 1316., 884.,  1012., 508.,  576.,  221.,  252.,
      502.,  568.,  847.,  952.,  937.,  1048., 702.,  780.,  391.,  432.,
      25.,   52.,   102.,  160.,  235.,  328.,  253.,  352.,  238.,  308.,
      155.,  192.,  208.,  276.,  548.,  692.,  1028., 1256., 1100., 1340.,
      900.,  1068., 536.,  624.,  597.,  720.,  1434., 1692., 2523., 2928.,
      2685., 3108., 2082., 2376., 1191., 1344., 716.,  812.,  1620., 1820.,
      2720., 3032., 2864., 3188., 2132., 2356., 1180., 1296., 533.,  588.,
      1174., 1288., 1927., 2104., 2017., 2200., 1470., 1596., 799.,  864.,
      49.,   100.,  198.,  304.,  451.,  616.,  469.,  640.,  430.,  548.,
      275.,  336.,  400.,  516.,  1028., 1268., 1892., 2264., 1964., 2348.,
      1572., 1836., 920.,  1056., 1101., 1296., 2586., 2988., 4467., 5088.,
      4629., 5268., 3522., 3960., 1983., 2208., 1196., 1340., 2676., 2972.,
      4448., 4904., 4592., 5060., 3380., 3700., 1852., 2016., 845.,  924.,
      1846., 2008., 3007., 3256., 3097., 3352., 2238., 2412., 1207., 1296.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      572.,   1004.,   1426.,  2170.,   1978.,   2818.,   2530.,  3466.,
      3082.,  4114.,   2796.,  3548.,   2766.,   3846.,   5649.,  7413.,
      6909.,  8817.,   8169.,  10221.,  9429.,   11625.,  7830.,  9390.,
      7230.,  8886.,   13209., 15837.,  14469.,  17241.,  15729., 18645.,
      16989., 20049.,  13446., 15582.,  11694.,  13926.,  20769., 24261.,
      22029., 25665.,  23289., 27069.,  24549.,  28473.,  19062., 21774.,
      14444., 16220.,  24250., 27010.,  25378.,  28234.,  26506., 29458.,
      27634., 30682.,  20508., 22604.,  9692.,   12044.,  17986., 21610.,
      18538., 22258.,  19090., 22906.,  19642.,  23554.,  15756., 18428.,
      25086., 29046.,  43449., 49533.,  44709.,  50937.,  45969., 52341.,
      47229., 53745.,  35910., 40350.,  29550.,  34086.,  51009., 57957.,
      52269., 59361.,  53529., 60765.,  54789.,  62169.,  41526., 46542.,
      34014., 39126.,  58569., 66381.,  59829.,  67785.,  61089., 69189.,
      62349., 70593.,  47142., 52734.,  35084.,  38780.,  58090., 63730.,
      59218., 64954.,  60346., 66178.,  61474.,  67402.,  44988., 49004.,
      18812., 23084.,  34546., 41050.,  35098.,  41698.,  35650., 42346.,
      36202., 42994.,  28716., 33308.,  47406.,  54246.,  81249., 91653.,
      82509., 93057.,  83769., 94461.,  85029.,  95865.,  63990., 71310.,
      51870., 59286.,  88809., 100077., 90069.,  101481., 91329., 102885.,
      92589., 104289., 69606., 77502.,  56334.,  64326.,  96369., 108501.,
      97629., 109905., 98889., 111309., 100149., 112713., 75222., 83694.,
      55724., 61340.,  91930., 100450., 93058.,  101674., 94186., 102898.,
      95314., 104122., 69468., 75404.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    34.,    106.,   119.,   275.,   251.,   455.,   330.,
      498.,   257.,   357.,   94.,    246.,   460.,   828.,   1162.,  1810.,
      1714.,  2458.,  1692.,  2252.,  1142.,  1454.,  651.,   1047.,  2046.,
      2934.,  4281.,  5757.,  5541.,  7161.,  4854.,  6030.,  3039.,  3675.,
      1798.,  2174.,  4316.,  5132.,  7618.,  8938.,  8746.,  10162., 6828.,
      7836.,  3934.,  4470.,  1709.,  1953.,  3890.,  4410.,  6575.,  7403.,
      7283.,  8159.,  5466.,  6082.,  3049.,  3373.,  149.,   361.,   706.,
      1162.,  1703.,  2435.,  1835.,  2615.,  1770.,  2322.,  1169.,  1461.,
      1534.,  2070.,  4108.,  5244.,  7786.,  9586.,  8338.,  10234., 6876.,
      8204.,  4118.,  4814.,  4539.,  5511.,  10974., 13014., 19401., 22605.,
      20661., 24009., 16086., 18414., 9231.,  10443., 5542.,  6302.,  12572.,
      14156., 21154., 23626., 22282., 24850., 16620., 18396., 9214.,  10134.,
      4157.,  4593.,  9170.,  10074., 15071., 16475., 15779., 17231., 11514.,
      12514., 6265.,  6781.,  293.,   697.,   1378.,  2218.,  3287.,  4595.,
      3419.,  4775.,  3210.,  4146.,  2081.,  2565.,  2974.,  3894.,  7756.,
      9660.,  14410., 17362., 14962., 18010., 12060., 14156., 7094.,  8174.,
      8427.,  9975.,  19902., 23094., 34521., 39453., 35781., 40857., 27318.,
      30798., 15423., 17211., 9286.,  10430., 20828., 23180., 34690., 38314.,
      35818., 39538., 26412., 28956., 14494., 15798., 6605.,  7233.,  14450.,
      15738., 23567., 25547., 24275., 26303., 17562., 18946., 9481.,  10189.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4184.,   7576.,   10724.,  16580.,  15044.,  21668.,  19364.,  26756.,
      23684.,  31844.,  21656.,  27608.,  21108.,  29652.,  43518.,  57486.,
      53454.,  68574.,  63390.,  79662.,  73326.,  90750.,  61140.,  73524.,
      56244.,  69396.,  103134., 124014., 113070., 135102., 123006., 146190.,
      132942., 157278., 105492., 122484., 91380.,  109140., 162750., 190542.,
      172686., 201630., 182622., 212718., 192558., 223806., 149844., 171444.,
      113816., 127960., 191300., 213284., 200228., 222980., 209156., 232676.,
      218084., 242372., 162008., 178712., 75224.,  93976.,  140324., 169220.,
      144644., 174308., 148964., 179396., 153284., 184484., 123416., 144728.,
      196788., 228372., 341598., 390126., 351534., 401214., 361470., 412302.,
      371406., 423390., 282900., 318324., 231924., 268116., 401214., 456654.,
      411150., 467742., 421086., 478830., 431022., 489918., 327252., 367284.,
      267060., 307860., 460830., 523182., 470766., 534270., 480702., 545358.,
      490638., 556446., 371604., 416244., 277016., 306520., 459140., 504164.,
      468068., 513860., 476996., 523556., 485924., 533252., 355928., 387992.,
      146264., 180376., 269924., 321860., 274244., 326948., 278564., 332036.,
      282884., 337124., 225176., 261848., 372468., 427092., 639678., 722766.,
      649614., 733854., 659550., 744942., 669486., 756030., 504660., 563124.,
      407604., 466836., 699294., 789294., 709230., 800382., 719166., 811470.,
      729102., 822558., 549012., 612084., 442740., 506580., 758910., 855822.,
      768846., 866910., 778782., 877998., 788718., 889086., 593364., 661044.,
      440216., 485080., 726980., 795044., 735908., 804740., 744836., 814436.,
      753764., 824132., 549848., 597272.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    220.,    764.,    826.,    2026.,   1834.,   3418.,
      2492.,   3804.,   1966.,   2750.,   620.,    1804.,   3352.,   6232.,
      8708.,   13796.,  13028.,  18884.,  13016.,  17432.,  8844.,   11308.,
      4842.,   7962.,   15540.,  22548.,  32862.,  44526.,  42798.,  55614.,
      37716.,  47028.,  23706.,  28746.,  14028.,  17004.,  33752.,  40216.,
      59684.,  70148.,  68612.,  79844.,  53656.,  61656.,  30956.,  35212.,
      13438.,  15374.,  30620.,  34748.,  51802.,  58378.,  57418.,  64378.,
      43132.,  48028.,  24078.,  26654.,  990.,    2670.,   5212.,   8828.,
      12922.,  18730.,  13930.,  20122.,  13628.,  18012.,  9070.,   11390.,
      11756.,  16012.,  31768.,  40792.,  60548.,  74852.,  64868.,  79940.,
      53720.,  64280.,  32268.,  37804.,  35370.,  43098.,  85812.,  102036.,
      152094., 177582., 162030., 188670., 126420., 144948., 72666.,  82314.,
      43596.,  49644.,  99032.,  111640., 166820., 186500., 175748., 196196.,
      131224., 145368., 72812.,  80140.,  32830.,  36302.,  72476.,  79676.,
      119194., 130378., 124810., 136378., 91132.,  99100.,  49614.,  53726.,
      1950.,   5166.,   10204.,  16892.,  25018.,  35434.,  26026.,  36826.,
      24764.,  32220.,  16174.,  20030.,  22892.,  30220.,  60184.,  75352.,
      112388., 135908., 116708., 140996., 94424.,  111128., 55692.,  64300.,
      65898.,  78234.,  156084., 181524., 271326., 310638., 281262., 321726.,
      215124., 242868., 121626., 135882., 73164.,  82284.,  164312., 183064.,
      273956., 302852., 282884., 312548., 208792., 229080., 114668., 125068.,
      52222.,  57230.,  114332., 124604., 186586., 202378., 192202., 208378.,
      139132., 150172., 75150.,  80798.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236.,   336.,   444.,   560.,   626.,   800.,   986.,   1184.,  890.,
      1088.,  1298.,  1520.,  1154.,  1376.,  1610.,  1856.,  1418.,  1664.,
      1922.,  2192.,  1308.,  1488.,  1676.,  1872.,  1254.,  1512.,  1782.,
      2064.,  2613.,  3036.,  3477.,  3936.,  3225.,  3684.,  4161.,  4656.,
      3837.,  4332.,  4845.,  5376.,  4449.,  4980.,  5529.,  6096.,  3726.,
      4104.,  4494.,  4896.,  3414.,  3816.,  4230.,  4656.,  6285.,  6924.,
      7581.,  8256.,  6897.,  7572.,  8265.,  8976.,  7509.,  8220.,  8949.,
      9696.,  8121.,  8868.,  9633.,  10416., 6462.,  6984.,  7518.,  8064.,
      5574.,  6120.,  6678.,  7248.,  9957.,  10812., 11685., 12576., 10569.,
      11460., 12369., 13296., 11181., 12108., 13053., 14016., 11793., 12756.,
      13737., 14736., 9198.,  9864.,  10542., 11232., 7004.,  7440.,  7884.,
      8336.,  11786., 12464., 13154., 13856., 12338., 13040., 13754., 14480.,
      12890., 13616., 14354., 15104., 13442., 14192., 14954., 15728., 9996.,
      10512., 11036., 11568., 4556.,  5136.,  5724.,  6320.,  8546.,  9440.,
      10346., 11264., 8810.,  9728.,  10658., 11600., 9074.,  10016., 10970.,
      11936., 9338.,  10304., 11282., 12272., 7548.,  8208.,  8876.,  9552.,
      12054., 13032., 14022., 15024., 20973., 22476., 23997., 25536., 21585.,
      23124., 24681., 26256., 22197., 23772., 25365., 26976., 22809., 24420.,
      26049., 27696., 17406., 18504., 19614., 20736., 14214., 15336., 16470.,
      17616., 24645., 26364., 28101., 29856., 25257., 27012., 28785., 30576.,
      25869., 27660., 29469., 31296., 26481., 28308., 30153., 32016., 20142.,
      21384., 22638., 23904., 16374., 17640., 18918., 20208., 28317., 30252.,
      32205., 34176., 28929., 30900., 32889., 34896., 29541., 31548., 33573.,
      35616., 30153., 32196., 34257., 36336., 22878., 24264., 25662., 27072.,
      17084., 18000., 18924., 19856., 28346., 29744., 31154., 32576., 28898.,
      30320., 31754., 33200., 29450., 30896., 32354., 33824., 30002., 31472.,
      32954., 34448., 21996., 22992., 23996., 25008., 8876.,  9936.,  11004.,
      12080., 16466., 18080., 19706., 21344., 16730., 18368., 20018., 21680.,
      16994., 18656., 20330., 22016., 17258., 18944., 20642., 22352., 13788.,
      14928., 16076., 17232., 22854., 24552., 26262., 27984., 39333., 41916.,
      44517., 47136., 39945., 42564., 45201., 47856., 40557., 43212., 45885.,
      48576., 41169., 43860., 46569., 49296., 31086., 32904., 34734., 36576.,
      25014., 26856., 28710., 30576., 43005., 45804., 48621., 51456., 43617.,
      46452., 49305., 52176., 44229., 47100., 49989., 52896., 44841., 47748.,
      50673., 53616., 33822., 35784., 37758., 39744., 27174., 29160., 31158.,
      33168., 46677., 49692., 52725., 55776., 47289., 50340., 53409., 56496.,
      47901., 50988., 54093., 57216., 48513., 51636., 54777., 57936., 36558.,
      38664., 40782., 42912., 27164., 28560., 29964., 31376., 44906., 47024.,
      49154., 51296., 45458., 47600., 49754., 51920., 46010., 48176., 50354.,
      52544., 46562., 48752., 50954., 53168., 33996., 35472., 36956., 38448.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,     4.,     9.,     16.,    10.,    24.,    42.,    64.,    43.,
      76.,    115.,   160.,   103.,   148.,   199.,   256.,   146.,   184.,
      226.,   272.,   117.,   140.,   165.,   192.,   30.,    64.,    102.,
      144.,   188.,   272.,   364.,   464.,   506.,   656.,   818.,   992.,
      770.,   944.,   1130.,  1328.,  780.,   912.,   1052.,  1200.,  534.,
      608.,   686.,   768.,   279.,   372.,   471.,   576.,   918.,   1128.,
      1350.,  1584.,  1965.,  2316.,  2685.,  3072.,  2577.,  2964.,  3369.,
      3792.,  2286.,  2568.,  2862.,  3168.,  1443.,  1596.,  1755.,  1920.,
      854.,   944.,   1038.,  1136.,  2060.,  2256.,  2460.,  2672.,  3650.,
      3968.,  4298.,  4640.,  4202.,  4544.,  4898.,  5264.,  3292.,  3536.,
      3788.,  4048.,  1902.,  2032.,  2166.,  2304.,  825.,   884.,   945.,
      1008.,  1882.,  2008.,  2138.,  2272.,  3187.,  3388.,  3595.,  3808.,
      3535.,  3748.,  3967.,  4192.,  2658.,  2808.,  2962.,  3120.,  1485.,
      1564.,  1645.,  1728.,  49.,    100.,   153.,   208.,   298.,   408.,
      522.,   640.,   763.,   940.,   1123.,  1312.,  823.,   1012.,  1207.,
      1408.,  818.,   952.,   1090.,  1232.,  549.,   620.,   693.,   768.,
      702.,   832.,   966.,   1104.,  1916.,  2192.,  2476.,  2768.,  3674.,
      4112.,  4562.,  5024.,  3938.,  4400.,  4874.,  5360.,  3276.,  3600.,
      3932.,  4272.,  1974.,  2144.,  2318.,  2496.,  2151.,  2388.,  2631.,
      2880.,  5238.,  5736.,  6246.,  6768.,  9309.,  10092., 10893., 11712.,
      9921.,  10740., 11577., 12432., 7758.,  8328.,  8910.,  9504.,  4467.,
      4764.,  5067.,  5376.,  2678.,  2864.,  3054.,  3248.,  6092.,  6480.,
      6876.,  7280.,  10274., 10880., 11498., 12128., 10826., 11456., 12098.,
      12752., 8092.,  8528.,  8972.,  9424.,  4494.,  4720.,  4950.,  5184.,
      2025.,  2132.,  2241.,  2352.,  4474.,  4696.,  4922.,  5152.,  7363.,
      7708.,  8059.,  8416.,  7711.,  8068.,  8431.,  8800.,  5634.,  5880.,
      6130.,  6384.,  3069.,  3196.,  3325.,  3456.,  97.,    196.,   297.,
      400.,   586.,   792.,   1002.,  1216.,  1483.,  1804.,  2131.,  2464.,
      1543.,  1876.,  2215.,  2560.,  1490.,  1720.,  1954.,  2192.,  981.,
      1100.,  1221.,  1344.,  1374.,  1600.,  1830.,  2064.,  3644.,  4112.,
      4588.,  5072.,  6842.,  7568.,  8306.,  9056.,  7106.,  7856.,  8618.,
      9392.,  5772.,  6288.,  6812.,  7344.,  3414.,  3680.,  3950.,  4224.,
      4023.,  4404.,  4791.,  5184.,  9558.,  10344., 11142., 11952., 16653.,
      17868., 19101., 20352., 17265., 18516., 19785., 21072., 13230., 14088.,
      14958., 15840., 7491.,  7932.,  8379.,  8832.,  4502.,  4784.,  5070.,
      5360.,  10124., 10704., 11292., 11888., 16898., 17792., 18698., 19616.,
      17450., 18368., 19298., 20240., 12892., 13520., 14156., 14800., 7086.,
      7408.,  7734.,  8064.,  3225.,  3380.,  3537.,  3696.,  7066.,  7384.,
      7706.,  8032.,  11539., 12028., 12523., 13024., 11887., 12388., 12895.,
      13408., 8610.,  8952.,  9298.,  9648.,  4653.,  4828.,  5005.,  5184.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1700.,   2484.,   3332.,   4244.,   4678.,   6046.,   7510.,   9070.,
      6742.,   8302.,   9958.,   11710.,  8806.,   10558.,  12406.,  14350.,
      10870.,  12814.,  14854.,  16990.,  10116.,  11540.,  13028.,  14580.,
      9534.,   11574.,  13710.,  15942.,  20085.,  23433.,  26925.,  30561.,
      24909.,  28545.,  32325.,  36249.,  29733.,  33657.,  37725.,  41937.,
      34557.,  38769.,  43125.,  47625.,  29070.,  32070.,  35166.,  38358.,
      26526.,  29718.,  33006.,  36390.,  49029.,  54105.,  59325.,  64689.,
      53853.,  59217.,  64725.,  70377.,  58677.,  64329.,  70125.,  76065.,
      63501.,  69441.,  75525.,  81753.,  50670.,  54822.,  59070.,  63414.,
      43518.,  47862.,  52302.,  56838.,  77973.,  84777.,  91725.,  98817.,
      82797.,  89889.,  97125.,  104505., 87621.,  95001.,  102525., 110193.,
      92445.,  100113., 107925., 115881., 72270.,  77574.,  82974.,  88470.,
      55172.,  58644.,  62180.,  65780.,  92950.,  98350.,  103846., 109438.,
      97318.,  102910., 108598., 114382., 101686., 107470., 113350., 119326.,
      106054., 112030., 118102., 124270., 78948.,  83060.,  87236.,  91476.,
      35300.,  39924.,  44612.,  49364.,  66598.,  73726.,  80950.,  88270.,
      68662.,  75982.,  83398.,  90910.,  70726.,  78238.,  85846.,  93550.,
      72790.,  80494.,  88294.,  96190.,  59076.,  64340.,  69668.,  75060.,
      94494.,  102294., 110190., 118182., 164805., 176793., 188925., 201201.,
      169629., 181905., 194325., 206889., 174453., 187017., 199725., 212577.,
      179277., 192129., 205125., 218265., 137070., 145830., 154686., 163638.,
      111486., 120438., 129486., 138630., 193749., 207465., 221325., 235329.,
      198573., 212577., 226725., 241017., 203397., 217689., 232125., 246705.,
      208221., 222801., 237525., 252393., 158670., 168582., 178590., 188694.,
      128478., 138582., 148782., 159078., 222693., 238137., 253725., 269457.,
      227517., 243249., 259125., 275145., 232341., 248361., 264525., 280833.,
      237165., 253473., 269925., 286521., 180270., 191334., 202494., 213750.,
      134852., 142164., 149540., 156980., 223990., 235150., 246406., 257758.,
      228358., 239710., 251158., 262702., 232726., 244270., 255910., 267646.,
      237094., 248830., 260662., 272590., 173988., 181940., 189956., 198036.,
      68900.,  77364.,  85892.,  94484.,  128518., 141406., 154390., 167470.,
      130582., 143662., 156838., 170110., 132646., 145918., 159286., 172750.,
      134710., 148174., 161734., 175390., 108036., 117140., 126308., 135540.,
      179454., 193014., 206670., 220422., 309525., 330153., 350925., 371841.,
      314349., 335265., 356325., 377529., 319173., 340377., 361725., 383217.,
      323997., 345489., 367125., 388905., 245070., 259590., 274206., 288918.,
      196446., 211158., 225966., 240870., 338469., 360825., 383325., 405969.,
      343293., 365937., 388725., 411657., 348117., 371049., 394125., 417345.,
      352941., 376161., 399525., 423033., 266670., 282342., 298110., 313974.,
      213438., 229302., 245262., 261318., 367413., 391497., 415725., 440097.,
      372237., 396609., 421125., 445785., 377061., 401721., 426525., 451473.,
      381885., 406833., 431925., 457161., 288270., 305094., 322014., 339030.,
      214532., 225684., 236900., 248180., 355030., 371950., 388966., 406078.,
      359398., 376510., 393718., 411022., 363766., 381070., 398470., 415966.,
      368134., 385630., 403222., 420910., 269028., 280820., 292676., 304596.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,      25.,     61.,     113.,    58.,     162.,    298.,    466.,
      287.,    539.,    839.,    1187.,   743.,    1091.,   1487.,   1931.,
      1098.,   1394.,   1722.,   2082.,   893.,    1073.,   1269.,   1481.,
      178.,    442.,    738.,    1066.,   1348.,   2004.,   2724.,   3508.,
      3766.,   4942.,   6214.,   7582.,   5830.,   7198.,   8662.,   10222.,
      5988.,   7028.,   8132.,   9300.,   4130.,   4714.,   5330.,   5978.,
      2055.,   2787.,   3567.,   4395.,   6942.,   8598.,   10350.,  12198.,
      15045.,  17817.,  20733.,  23793.,  19869.,  22929.,  26133.,  29481.,
      17742.,  19974.,  22302.,  24726.,  11247.,  12459.,  13719.,  15027.,
      6658.,   7370.,   8114.,   8890.,   16100.,  17652.,  19268.,  20948.,
      28582.,  31102.,  33718.,  36430.,  32950.,  35662.,  38470.,  41374.,
      25860.,  27796.,  29796.,  31860.,  14962.,  15994.,  17058.,  18154.,
      6485.,   6953.,   7437.,   7937.,   14810.,  15810.,  16842.,  17906.,
      25103.,  26699.,  28343.,  30035.,  27863.,  29555.,  31295.,  33083.,
      20970.,  22162.,  23386.,  24642.,  11725.,  12353.,  12997.,  13657.,
      293.,    697.,    1117.,   1553.,   2170.,   3042.,   3946.,   4882.,
      5759.,   7163.,   8615.,   10115.,  6215.,   7715.,   9263.,   10859.,
      6282.,   7346.,   8442.,   9570.,   4253.,   4817.,   5397.,   5993.,
      5362.,   6394.,   7458.,   8554.,   14788.,  16980.,  19236.,  21556.,
      28534.,  32014.,  35590.,  39262.,  30598.,  34270.,  38038.,  41902.,
      25572.,  28148.,  30788.,  33492.,  15458.,  16810.,  18194.,  19610.,
      16743.,  18627.,  20559.,  22539.,  40926.,  44886.,  48942.,  53094.,
      72933.,  79161.,  85533.,  92049.,  77757.,  84273.,  90933.,  97737.,
      60942.,  65478.,  70110.,  74838.,  35151.,  37515.,  39927.,  42387.,
      21058.,  22538.,  24050.,  25594.,  47972.,  51060.,  54212.,  57428.,
      80998.,  85822.,  90742.,  95758.,  85366.,  90382.,  95494.,  100702.,
      63876.,  67348.,  70884.,  74484.,  35506.,  37306.,  39138.,  41002.,
      15989.,  16841.,  17709.,  18593.,  35354.,  37122.,  38922.,  40754.,
      58223.,  60971.,  63767.,  66611.,  60983.,  63827.,  66719.,  69659.,
      44586.,  46546.,  48538.,  50562.,  24301.,  25313.,  26341.,  27385.,
      581.,    1369.,   2173.,   2993.,   4282.,   5922.,   7594.,   9298.,
      11231.,  13787.,  16391.,  19043.,  11687.,  14339.,  17039.,  19787.,
      11466.,  13298.,  15162.,  17058.,  7613.,   8561.,   9525.,   10505.,
      10546.,  12346.,  14178.,  16042.,  28228.,  31956.,  35748.,  39604.,
      53302.,  59086.,  64966.,  70942.,  55366.,  61342.,  67414.,  73582.,
      45156.,  49268.,  53444.,  57684.,  26786.,  28906.,  31058.,  33242.,
      31431.,  34467.,  37551.,  40683.,  74910.,  81174.,  87534.,  93990.,
      130821., 140505., 150333., 160305., 135645., 145617., 155733., 165993.,
      104142., 110982., 117918., 124950., 59055.,  62571.,  66135.,  69747.,
      35458.,  37706.,  39986.,  42298.,  79844.,  84468.,  89156.,  93908.,
      133414., 140542., 147766., 155086., 137782., 145102., 152518., 160030.,
      101892., 106900., 111972., 117108., 56050.,  58618.,  61218.,  63850.,
      25493.,  26729.,  27981.,  29249.,  55898.,  58434.,  61002.,  63602.,
      91343.,  95243.,  99191.,  103187., 94103.,  98099.,  102143., 106235.,
      68202.,  70930.,  73690.,  76482.,  36877.,  38273.,  39685.,  41113.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12856.,   19064.,   25784.,   33016.,   36116.,   46964.,   58580.,
      70964.,   52436.,   64820.,   77972.,   91892.,   68756.,   82676.,
      97364.,   112820.,  85076.,   100532.,  116756.,  133748.,  79544.,
      90872.,   102712.,  115064.,  74292.,   90516.,   107508.,  125268.,
      157422.,  184062.,  211854.,  240798.,  195726.,  224670.,  254766.,
      286014.,  234030.,  265278.,  297678.,  331230.,  272334.,  305886.,
      340590.,  376446.,  229620.,  253524.,  278196.,  303636.,  209076.,
      234516.,  260724.,  287700.,  387246.,  427710.,  469326.,  512094.,
      425550.,  468318.,  512238.,  557310.,  463854.,  508926.,  555150.,
      602526.,  502158.,  549534.,  598062.,  647742.,  401268.,  434388.,
      468276.,  502932.,  343860.,  378516.,  413940.,  450132.,  617070.,
      671358.,  726798.,  783390.,  655374.,  711966.,  769710.,  828606.,
      693678.,  752574.,  812622.,  873822.,  731982.,  793182.,  855534.,
      919038.,  572916.,  615252.,  658356.,  702228.,  437944.,  465656.,
      493880.,  522616.,  738260.,  781364.,  825236.,  869876.,  773012.,
      817652.,  863060.,  909236.,  807764.,  853940.,  900884.,  948596.,
      842516.,  890228.,  938708.,  987956.,  627512.,  660344.,  693688.,
      727544.,  277816.,  314744.,  352184.,  390136.,  525716.,  582644.,
      640340.,  698804.,  542036.,  600500.,  659732.,  719732.,  558356.,
      618356.,  679124.,  740660.,  574676.,  636212.,  698516.,  761588.,
      467384.,  509432.,  551992.,  595064.,  748212.,  810516.,  873588.,
      937428.,  1306542., 1402302., 1499214., 1597278., 1344846., 1442910.,
      1542126., 1642494., 1383150., 1483518., 1585038., 1687710., 1421454.,
      1524126., 1627950., 1732926., 1087860., 1157844., 1228596., 1300116.,
      882996.,  954516.,  1026804., 1099860., 1536366., 1645950., 1756686.,
      1868574., 1574670., 1686558., 1799598., 1913790., 1612974., 1727166.,
      1842510., 1959006., 1651278., 1767774., 1885422., 2004222., 1259508.,
      1338708., 1418676., 1499412., 1017780., 1098516., 1180020., 1262292.,
      1766190., 1889598., 2014158., 2139870., 1804494., 1930206., 2057070.,
      2185086., 1842798., 1970814., 2099982., 2230302., 1881102., 2011422.,
      2142894., 2275518., 1431156., 1519572., 1608756., 1698708., 1071544.,
      1129976., 1188920., 1248376., 1780820., 1870004., 1959956., 2050676.,
      1815572., 1906292., 1997780., 2090036., 1850324., 1942580., 2035604.,
      2129396., 1885076., 1978868., 2073428., 2168756., 1383992., 1447544.,
      1511608., 1576184., 542776.,  610424.,  678584.,  747256.,  1015316.,
      1118324., 1222100., 1326644., 1031636., 1136180., 1241492., 1347572.,
      1047956., 1154036., 1260884., 1368500., 1064276., 1171892., 1280276.,
      1389428., 855224.,  927992.,  1001272., 1075064., 1422132., 1530516.,
      1639668., 1749588., 2455662., 2620542., 2786574., 2953758., 2493966.,
      2661150., 2829486., 2998974., 2532270., 2701758., 2872398., 3044190.,
      2570574., 2742366., 2915310., 3089406., 1946100., 2062164., 2178996.,
      2296596., 1556916., 1674516., 1792884., 1912020., 2685486., 2864190.,
      3044046., 3225054., 2723790., 2904798., 3086958., 3270270., 2762094.,
      2945406., 3129870., 3315486., 2800398., 2986014., 3172782., 3360702.,
      2117748., 2243028., 2369076., 2495892., 1691700., 1818516., 1946100.,
      2074452., 2915310., 3107838., 3301518., 3496350., 2953614., 3148446.,
      3344430., 3541566., 2991918., 3189054., 3387342., 3586782., 3030222.,
      3229662., 3430254., 3631998., 2289396., 2423892., 2559156., 2695188.,
      1705144., 1794296., 1883960., 1974136., 2823380., 2958644., 3094676.,
      3231476., 2858132., 2994932., 3132500., 3270836., 2892884., 3031220.,
      3170324., 3310196., 2927636., 3067508., 3208148., 3349556., 2140472.,
      2234744., 2329528., 2424824.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,      174.,     446.,     846.,     380.,     1180.,    2236.,
      3548.,    2074.,    4042.,    6394.,    9130.,    5626.,    8362.,
      11482.,   14986.,   8508.,    10844.,   13436.,   16284.,   6974.,
      8398.,    9950.,    11630.,   1180.,    3260.,    5596.,    8188.,
      10168.,   15352.,   21048.,   27256.,   29012.,   38324.,   48404.,
      59252.,   45332.,   56180.,   67796.,   80180.,   46904.,   55160.,
      63928.,   73208.,   32476.,   37116.,   42012.,   47164.,   15738.,
      21546.,   27738.,   34314.,   53940.,   67092.,   81012.,   95700.,
      117678.,  139710.,  162894.,  187230.,  155982.,  180318.,  205806.,
      232446.,  139764.,  157524.,  176052.,  195348.,  88794.,   98442.,
      108474.,  118890.,  52572.,   58236.,   64156.,   70332.,   127288.,
      139640.,  152504.,  165880.,  226196.,  246260.,  267092.,  288692.,
      260948.,  282548.,  304916.,  328052.,  204984.,  220408.,  236344.,
      252792.,  118684.,  126908.,  135388.,  144124.,  51422.,   55150.,
      59006.,   62990.,   117500.,  125468.,  133692.,  142172.,  199258.,
      211978.,  225082.,  238570.,  221242.,  234730.,  248602.,  262858.,
      166588.,  176092.,  185852.,  195868.,  93182.,   98190.,   103326.,
      108590.,  1950.,    5166.,    8510.,    11982.,   16508.,   23452.,
      30652.,   38108.,   44698.,   55882.,   67450.,   79402.,   48250.,
      60202.,   72538.,   85258.,   49212.,   57692.,   66428.,   75420.,
      33470.,   37966.,   42590.,   47342.,   41884.,   50108.,   58588.,
      67324.,   116152.,  133624.,  151608.,  170104.,  224852.,  252596.,
      281108.,  310388.,  241172.,  270452.,  300500.,  331316.,  202040.,
      222584.,  243640.,  265208.,  122332.,  133116.,  144156.,  155452.,
      132090.,  147114.,  162522.,  178314.,  323508.,  355092.,  387444.,
      420564.,  577326.,  627006.,  677838.,  729822.,  615630.,  667614.,
      720750.,  775038.,  483060.,  519252.,  556212.,  593940.,  278874.,
      297738.,  316986.,  336618.,  167004.,  178812.,  190876.,  203196.,
      380728.,  405368.,  430520.,  456184.,  643220.,  681716.,  720980.,
      761012.,  677972.,  718004.,  758804.,  800372.,  507576.,  535288.,
      563512.,  592248.,  282268.,  296636.,  311260.,  326140.,  127070.,
      133870.,  140798.,  147854.,  281084.,  295196.,  309564.,  324188.,
      463066.,  485002.,  507322.,  530026.,  485050.,  507754.,  530842.,
      554314.,  354748.,  370396.,  386300.,  402460.,  193406.,  201486.,
      209694.,  218030.,  3870.,    10158.,   16574.,   23118.,   32636.,
      45724.,   59068.,   72668.,   87322.,   107722.,  128506.,  149674.,
      90874.,   112042.,  133594.,  155530.,  89916.,   104540.,  119420.,
      134556.,  59966.,   67534.,   75230.,   83054.,   82588.,   96956.,
      111580.,  126460.,  222136.,  251896.,  282168.,  312952.,  420692.,
      466868.,  513812.,  561524.,  437012.,  484724.,  533204.,  582452.,
      357176.,  390008.,  423352.,  457208.,  212188.,  229116.,  246300.,
      263740.,  248442.,  272682.,  297306.,  322314.,  593076.,  643092.,
      693876.,  745428.,  1036974., 1114302., 1192782., 1272414., 1075278.,
      1154910., 1235694., 1317630., 826356.,  880980.,  936372.,  992532.,
      468954.,  497034.,  525498.,  554346.,  281436.,  299388.,  317596.,
      336060.,  634168.,  671096.,  708536.,  746488.,  1060244., 1117172.,
      1174868., 1233332., 1094996., 1153460., 1212692., 1272692., 810168.,
      850168.,  890680.,  931704.,  445852.,  466364.,  487132.,  508156.,
      202718.,  212590.,  222590.,  232718.,  444668.,  464924.,  485436.,
      506204.,  726874.,  758026.,  789562.,  821482.,  748858.,  780778.,
      813082.,  845770.,  542908.,  564700.,  586748.,  609052.,  293630.,
      304782.,  316062.,  327470.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,   62.,   83.,   75.,   99.,   192.,  237.,  198.,  207.,
      372.,  417.,  330.,  315.,  552.,  597.,  462.,  423.,  732.,
      777.,  594.,  455.,  758.,  797.,  589.,  317.,  566.,  587.,
      459.,  747.,  1272., 1317., 990.,  855.,  1452., 1497., 1122.,
      963.,  1632., 1677., 1254., 1071., 1812., 1857., 1386., 1031.,
      1694., 1733., 1261., 605.,  1070., 1091., 843.,  1395., 2352.,
      2397., 1782., 1503., 2532., 2577., 1914., 1611., 2712., 2757.,
      2046., 1719., 2892., 2937., 2178., 1607., 2630., 2669., 1933.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   7.,   6.,   7.,   23.,  33.,  24.,  24.,  69.,  90.,  60.,
      48.,  123., 156., 96.,  63.,  149., 175., 102., 49.,  112., 127., 72.,
      9.,   28.,  47.,  30.,  47.,  119., 161., 96.,  120., 285., 354., 204.,
      144., 339., 420., 240., 151., 341., 399., 222., 105., 232., 263., 144.,
      17.,  52.,  87.,  54.,  87.,  215., 289., 168., 216., 501., 618., 348.,
      240., 555., 684., 384., 239., 533., 623., 342., 161., 352., 399., 216.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      184.,   412.,   568.,   528.,   678.,   1347.,  1689.,  1434.,  1494.,
      2715.,  3057.,  2442.,  2310.,  4083.,  4425.,  3450.,  3126.,  5451.,
      5793.,  4458.,  3440.,  5752.,  6052.,  4488.,  2296.,  4156.,  4312.,
      3408.,  5574.,  9555.,  9897.,  7482.,  6390.,  10923., 11265., 8490.,
      7206.,  12291., 12633., 9498.,  8022.,  13659., 14001., 10506., 7856.,
      12952., 13252., 9672.,  4408.,  7900.,  8056.,  6288.,  10470., 17763.,
      18105., 13530., 11286., 19131., 19473., 14538., 12102., 20499., 20841.,
      15546., 12918., 21867., 22209., 16554., 12272., 20152., 20452., 14856.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   42.,   39.,   40.,   144.,  216.,  164.,  153.,
      462.,  618.,  423.,  333.,  870.,  1122., 699.,  460.,  1096.,
      1296., 760.,  365.,  838.,  954.,  543.,  53.,   182.,  330.,
      215.,  328.,  848.,  1176., 708.,  873.,  2094., 2634., 1527.,
      1053., 2502., 3138., 1803., 1132., 2568., 3024., 1688., 797.,
      1766., 2010., 1103., 101.,  342.,  618.,  391.,  616.,  1552.,
      2136., 1252., 1593., 3726., 4650., 2631., 1773., 4134., 5154.,
      2907., 1804., 4040., 4752., 2616., 1229., 2694., 3066., 1663.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1288.,   2972.,   4172.,   3944.,   4980.,  10038.,  12702.,  10884.,
      11316.,  20694.,  23358.,  18756.,  17652., 31350.,  34014.,  26628.,
      23988.,  42006.,  44670.,  34500.,  26728., 44780.,  47132.,  35016.,
      17416.,  31772.,  32972.,  26216.,  42996., 73974.,  76638.,  58116.,
      49332.,  84630.,  87294.,  65988.,  55668., 95286.,  97950.,  73860.,
      62004.,  105942., 108606., 81732.,  61288., 101228., 103580., 75720.,
      33544.,  60572.,  61772.,  48488.,  81012., 137910., 140574., 105348.,
      87348.,  148566., 151230., 113220., 93684., 159222., 161886., 121092.,
      100020., 169878., 172542., 128964., 95848., 157676., 160028., 116424.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   284.,   278.,   260.,   1000.,  1544.,  1204.,  1074.,
      3348.,  4548.,  3162.,  2466.,  6516.,  8484.,  5322.,  3508.,  8392.,
      9960.,  5860.,  2814.,  6476.,  7388.,  4214.,  350.,   1292.,  2460.,
      1622.,  2436.,  6376.,  8968.,  5428.,  6642.,  16020., 20292., 11802.,
      8034.,  19188., 24228., 13962., 8756.,  19912., 23528., 13156., 6206.,
      13772., 15708., 8630.,  670.,   2444.,  4636.,  2966.,  4612.,  11752.,
      16392., 9652.,  12210., 28692., 36036., 20442., 13602., 31860., 39972.,
      22602., 14004., 31432., 37096., 20452., 9598.,  21068., 24028., 13046.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68.,    116.,  164.,  248.,  236.,   332.,   228.,   300.,   282.,
      396.,   579.,  768.,  741.,  948.,   642.,   792.,   666.,   828.,
      1227.,  1488., 1389., 1668., 1122.,  1320.,  1050.,  1260.,  1875.,
      2208.,  2037., 2388., 1602., 1848.,  1434.,  1692.,  2523.,  2928.,
      2685.,  3108., 2082., 2376., 1620.,  1820.,  2720.,  3032.,  2864.,
      3188.,  2132., 2356., 1028., 1268.,  1892.,  2264.,  1964.,  2348.,
      1572.,  1836., 2586., 2988., 4467.,  5088.,  4629.,  5268.,  3522.,
      3960.,  2970., 3420., 5115., 5808.,  5277.,  5988.,  4002.,  4488.,
      3354.,  3852., 5763., 6528., 5925.,  6708.,  4482.,  5016.,  3738.,
      4284.,  6411., 7248., 6573., 7428.,  4962.,  5544.,  3732.,  4124.,
      6176.,  6776., 6320., 6932., 4628.,  5044.,  1988.,  2420.,  3620.,
      4280.,  3692., 4364., 2916., 3372.,  4890.,  5580.,  8355.,  9408.,
      8517.,  9588., 6402., 7128., 5274.,  6012.,  9003.,  10128., 9165.,
      10308., 6882., 7656., 5658., 6444.,  9651.,  10848., 9813.,  11028.,
      7362.,  8184., 6042., 6876., 10299., 11568., 10461., 11748., 7842.,
      8712.,  5844., 6428., 9632., 10520., 9776.,  10676., 7124.,  7732.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    6.,    16.,   14.,   28.,   15.,   24.,   12.,   28.,
      52.,   92.,   84.,   132.,  68.,   96.,   57.,   96.,   186.,  276.,
      258.,  360.,  183.,  240.,  141.,  192.,  378.,  492.,  498.,  624.,
      315.,  384.,  208.,  252.,  500.,  596.,  596.,  700.,  352.,  408.,
      169.,  196.,  390.,  448.,  446.,  508.,  255.,  288.,  17.,   36.,
      70.,   112.,  142.,  188.,  95.,   120.,  140.,  188.,  372.,  476.,
      532.,  644.,  324.,  384.,  393.,  480.,  954.,  1140., 1218., 1416.,
      711.,  816.,  477.,  576.,  1146., 1356., 1458., 1680., 843.,  960.,
      528.,  604.,  1204., 1364., 1428., 1596., 800.,  888.,  377.,  420.,
      838.,  928.,  958.,  1052., 527.,  576.,  33.,   68.,   134.,  208.,
      270.,  348.,  175.,  216.,  268.,  348.,  692.,  860.,  980.,  1156.,
      580.,  672.,  729.,  864.,  1722., 2004., 2178., 2472., 1239., 1392.,
      813.,  960.,  1914., 2220., 2418., 2736., 1371., 1536., 848.,  956.,
      1908., 2132., 2260., 2492., 1248., 1368., 585.,  644.,  1286., 1408.,
      1470., 1596., 799.,  864.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      460.,   828.,   1162.,  1810.,  1714.,  2458.,  1692.,  2252.,  2046.,
      2934.,  4281.,  5757.,  5541.,  7161.,  4854.,  6030.,  5022.,  6294.,
      9321.,  11373., 10581., 12777., 8598.,  10158., 7998.,  9654.,  14361.,
      16989., 15621., 18393., 12342., 14286., 10974., 13014., 19401., 22605.,
      20661., 24009., 16086., 18414., 12572., 14156., 21154., 23626., 22282.,
      24850., 16620., 18396., 7756.,  9660.,  14410., 17362., 14962., 18010.,
      12060., 14156., 19902., 23094., 34521., 39453., 35781., 40857., 27318.,
      30798., 22878., 26454., 39561., 45069., 40821., 46473., 31062., 34926.,
      25854., 29814., 44601., 50685., 45861., 52089., 34806., 39054., 28830.,
      33174., 49641., 56301., 50901., 57705., 38550., 43182., 29084., 32204.,
      48226., 53002., 49354., 54226., 36204., 39516., 15052., 18492., 27658.,
      32914., 28210., 33562., 22428., 26060., 37758., 43254., 64761., 73149.,
      66021., 74553., 49782., 55566., 40734., 46614., 69801., 78765., 71061.,
      80169., 53526., 59694., 43710., 49974., 74841., 84381., 76101., 85785.,
      57270., 63822., 46686., 53334., 79881., 89997., 81141., 91401., 61014.,
      67950., 45596., 50252., 75298., 82378., 76426., 83602., 55788., 60636.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    34.,    106.,   90.,    194.,   105.,   173.,   70.,
      190.,   348.,   652.,   588.,   956.,   494.,   710.,   387.,   687.,
      1326.,  2022.,  1878.,  2670.,  1359.,  1803.,  1035.,  1431.,  2814.,
      3702.,  3750.,  4734.,  2391.,  2931.,  1582.,  1926.,  3820.,  4572.,
      4572.,  5388.,  2710.,  3150.,  1301.,  1513.,  3010.,  3466.,  3450.,
      3938.,  1977.,  2237.,  101.,   249.,   482.,   810.,   1050.,  1410.,
      713.,   909.,   1030.,  1406.,  2780.,  3596.,  4044.,  4924.,  2478.,
      2950.,  2979.,  3663.,  7278.,  8742.,  9366.,  10926., 5487.,  6315.,
      3627.,  4407.,  8766.,  10422., 11238., 12990., 6519.,  7443.,  4078.,
      4678.,  9324.,  10588., 11100., 12428., 6230.,  6926.,  2933.,  3273.,
      6530.,  7242.,  7482.,  8226.,  4121.,  4509.,  197.,   473.,   930.,
      1514.,  2010.,  2626.,  1321.,  1645.,  1990.,  2622.,  5212.,  6540.,
      7500.,  8892.,  4462.,  5190.,  5571.,  6639.,  13230., 15462., 16854.,
      19182., 9615.,  10827., 6219.,  7383.,  14718., 17142., 18726., 21246.,
      10647., 11955., 6574.,  7430.,  14828., 16604., 17628., 19468., 9750.,
      10702., 4565.,  5033.,  10050., 11018., 11514., 12514., 6265.,  6781.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3352.,   6232.,   8708.,   13796.,  13028.,  18884.,  13016.,  17432.,
      15540.,  22548.,  32862.,  44526.,  42798.,  55614.,  37716.,  47028.,
      38964.,  49044.,  72606.,  88878.,  82542.,  99966.,  67284.,  79668.,
      62388.,  75540.,  112350., 133230., 122286., 144318., 96852.,  112308.,
      85812.,  102036., 152094., 177582., 162030., 188670., 126420., 144948.,
      99032.,  111640., 166820., 186500., 175748., 196196., 131224., 145368.,
      60184.,  75352.,  112388., 135908., 116708., 140996., 94424.,  111128.,
      156084., 181524., 271326., 310638., 281262., 321726., 215124., 242868.,
      179508., 208020., 311070., 354990., 321006., 366078., 244692., 275508.,
      202932., 234516., 350814., 399342., 360750., 410430., 274260., 308148.,
      226356., 261012., 390558., 443694., 400494., 454782., 303828., 340788.,
      229592., 254488., 381092., 419204., 390020., 428900., 286360., 312792.,
      117016., 144472., 216068., 258020., 220388., 263108., 175832., 204824.,
      296628., 340500., 509790., 576750., 519726., 587838., 392532., 438708.,
      320052., 366996., 549534., 621102., 559470., 632190., 422100., 471348.,
      343476., 393492., 589278., 665454., 599214., 676542., 451668., 503988.,
      366900., 419988., 629022., 709806., 638958., 720894., 481236., 536628.,
      360152., 397336., 595364., 651908., 604292., 661604., 441496., 480216.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    174.,   220.,    764.,    636.,    1436.,   782.,   1310.,
      460.,   1388.,  2520.,   4888.,   4376.,   7256.,   3756.,  5452.,
      2826.,  5178.,  9972.,   15444.,  14292.,  20532.,  10458., 13962.,
      7914.,  11034., 21684.,  28692.,  29076.,  36852.,  18618., 22890.,
      12332., 15052., 29848.,  35800.,  35800.,  42264.,  21260., 24748.,
      10206., 11886., 23644.,  27260.,  27132.,  31004.,  15566., 17630.,
      670.,   1838.,  3548.,   6140.,   8060.,   10908.,  5518.,  7070.,
      7884.,  10860., 21464.,  27928.,  31512.,  38488.,  19372., 23116.,
      23178., 28602., 56820.,  68436.,  73428.,  85812.,  43098., 49674.,
      28266., 34458., 68532.,  81684.,  88212.,  102132., 51258., 58602.,
      32044., 36812., 73368.,  83416.,  87512.,  98072.,  49164., 54700.,
      23134., 25838., 51548.,  57212.,  59132.,  65052.,  32590., 35678.,
      1310.,  3502.,  6876.,   11516.,  15484.,  20380.,  10254., 12830.,
      15308., 20332., 40408.,  50968.,  58648.,  69720.,  34988., 40780.,
      43530., 52026., 103668., 121428., 132564., 151092., 75738., 85386.,
      48618., 57882., 115380., 134676., 147348., 167412., 83898., 94314.,
      51756., 58572., 116888., 131032., 139224., 153880., 77068., 84652.,
      36062., 39790., 79452.,  87164.,  91132.,  99100.,  49614., 53726.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      188.,   272.,   364.,   464.,   506.,   656.,   818.,   992.,   770.,
      944.,   1130.,  1328.,  780.,   912.,   1052.,  1200.,  918.,   1128.,
      1350.,  1584.,  1965.,  2316.,  2685.,  3072.,  2577.,  2964.,  3369.,
      3792.,  2286.,  2568.,  2862.,  3168.,  2358.,  2664.,  2982.,  3312.,
      4413.,  4908.,  5421.,  5952.,  5025.,  5556.,  6105.,  6672.,  4110.,
      4488.,  4878.,  5280.,  3798.,  4200.,  4614.,  5040.,  6861.,  7500.,
      8157.,  8832.,  7473.,  8148.,  8841.,  9552.,  5934.,  6408.,  6894.,
      7392.,  5238.,  5736.,  6246.,  6768.,  9309.,  10092., 10893., 11712.,
      9921.,  10740., 11577., 12432., 7758.,  8328.,  8910.,  9504.,  6092.,
      6480.,  6876.,  7280.,  10274., 10880., 11498., 12128., 10826., 11456.,
      12098., 12752., 8092.,  8528.,  8972.,  9424.,  3644.,  4112.,  4588.,
      5072.,  6842.,  7568.,  8306.,  9056.,  7106.,  7856.,  8618.,  9392.,
      5772.,  6288.,  6812.,  7344.,  9558.,  10344., 11142., 11952., 16653.,
      17868., 19101., 20352., 17265., 18516., 19785., 21072., 13230., 14088.,
      14958., 15840., 10998., 11880., 12774., 13680., 19101., 20460., 21837.,
      23232., 19713., 21108., 22521., 23952., 15054., 16008., 16974., 17952.,
      12438., 13416., 14406., 15408., 21549., 23052., 24573., 26112., 22161.,
      23700., 25257., 26832., 16878., 17928., 18990., 20064., 13878., 14952.,
      16038., 17136., 23997., 25644., 27309., 28992., 24609., 26292., 27993.,
      29712., 18702., 19848., 21006., 22176., 14156., 14928., 15708., 16496.,
      23522., 24704., 25898., 27104., 24074., 25280., 26498., 27728., 17692.,
      18512., 19340., 20176., 7100.,  7952.,  8812.,  9680.,  13178., 14480.,
      15794., 17120., 13442., 14768., 16106., 17456., 10764., 11664., 12572.,
      13488., 18198., 19560., 20934., 22320., 31341., 33420., 35517., 37632.,
      31953., 34068., 36201., 38352., 24174., 25608., 27054., 28512., 19638.,
      21096., 22566., 24048., 33789., 36012., 38253., 40512., 34401., 36660.,
      38937., 41232., 25998., 27528., 29070., 30624., 21078., 22632., 24198.,
      25776., 36237., 38604., 40989., 43392., 36849., 39252., 41673., 44112.,
      27822., 29448., 31086., 32736., 22518., 24168., 25830., 27504., 38685.,
      41196., 43725., 46272., 39297., 41844., 44409., 46992., 29646., 31368.,
      33102., 34848., 22220., 23376., 24540., 25712., 36770., 38528., 40298.,
      42080., 37322., 39104., 40898., 42704., 27292., 28496., 29708., 30928.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,     4.,     9.,    16.,   10.,   24.,   42.,   64.,   34.,   56.,
      82.,    112.,   45.,   60.,   77.,   96.,   22.,   48.,   78.,   112.,
      140.,   208.,   284.,  368.,  252.,  336.,  428.,  528.,  222.,  272.,
      326.,   384.,   159.,  228.,  303.,  384.,  582.,  744.,  918.,  1104.,
      846.,   1032.,  1230., 1440., 627.,  732.,  843.,  960.,  471.,  564.,
      663.,   768.,   1302., 1512., 1734., 1968., 1758., 1992., 2238., 2496.,
      1131.,  1260.,  1395., 1536., 750.,  832.,  918.,  1008., 1820., 2000.,
      2188.,  2384.,  2188., 2384., 2588., 2800., 1302., 1408., 1518., 1632.,
      625.,   676.,   729.,  784.,  1450., 1560., 1674., 1792., 1666., 1784.,
      1906.,  2032.,  957.,  1020., 1085., 1152., 33.,   68.,   105.,  144.,
      202.,   280.,   362.,  448.,  482.,  568.,  658.,  752.,  333.,  380.,
      429.,   480.,   470.,  560.,  654.,  752.,  1292., 1488., 1692., 1904.,
      1916.,  2128.,  2348., 2576., 1182., 1296., 1414., 1536., 1407., 1572.,
      1743.,  1920.,  3462., 3816., 4182., 4560., 4494., 4872., 5262., 5664.,
      2643.,  2844.,  3051., 3264., 1719., 1908., 2103., 2304., 4182., 4584.,
      4998.,  5424.,  5406., 5832., 6270., 6720., 3147., 3372., 3603., 3840.,
      1966.,  2112.,  2262., 2416., 4508., 4816., 5132., 5456., 5388., 5712.,
      6044.,  6384.,  3030., 3200., 3374., 3552., 1425., 1508., 1593., 1680.,
      3178.,  3352.,  3530., 3712., 3650., 3832., 4018., 4208., 2013., 2108.,
      2205.,  2304.,  65.,   132.,  201.,  272.,  394.,  536.,  682.,  832.,
      930.,   1080.,  1234., 1392., 621.,  700.,  781.,  864.,  918.,  1072.,
      1230.,  1392.,  2444., 2768., 3100., 3440., 3580., 3920., 4268., 4624.,
      2142.,  2320.,  2502., 2688., 2655., 2916., 3183., 3456., 6342., 6888.,
      7446.,  8016.,  8142., 8712., 9294., 9888., 4659., 4956., 5259., 5568.,
      2967.,  3252.,  3543., 3840., 7062., 7656., 8262., 8880., 9054., 9672.,
      10302., 10944., 5163., 5484., 5811., 6144., 3182., 3392., 3606., 3824.,
      7196.,  7632.,  8076., 8528., 8588., 9040., 9500., 9968., 4758., 4992.,
      5230.,  5472.,  2225., 2340., 2457., 2576., 4906., 5144., 5386., 5632.,
      5634.,  5880.,  6130., 6384., 3069., 3196., 3325., 3456.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1348.,   2004.,   2724.,   3508.,   3766.,   4942.,   6214.,   7582.,
      5830.,   7198.,   8662.,   10222.,  5988.,   7028.,   8132.,   9300.,
      6942.,   8598.,   10350.,  12198.,  15045.,  17817.,  20733.,  23793.,
      19869.,  22929.,  26133.,  29481.,  17742.,  19974.,  22302.,  24726.,
      18270.,  20694.,  23214.,  25830.,  34341.,  38265.,  42333.,  46545.,
      39165.,  43377.,  47733.,  52233.,  32142.,  35142.,  38238.,  41430.,
      29598.,  32790.,  36078.,  39462.,  53637.,  58713.,  63933.,  69297.,
      58461.,  63825.,  69333.,  74985.,  46542.,  50310.,  54174.,  58134.,
      40926.,  44886.,  48942.,  53094.,  72933.,  79161.,  85533.,  92049.,
      77757.,  84273.,  90933.,  97737.,  60942.,  65478.,  70110.,  74838.,
      47972.,  51060.,  54212.,  57428.,  80998.,  85822.,  90742.,  95758.,
      85366.,  90382.,  95494.,  100702., 63876.,  67348.,  70884.,  74484.,
      28228.,  31956.,  35748.,  39604.,  53302.,  59086.,  64966.,  70942.,
      55366.,  61342.,  67414.,  73582.,  45156.,  49268.,  53444.,  57684.,
      74910.,  81174.,  87534.,  93990.,  130821., 140505., 150333., 160305.,
      135645., 145617., 155733., 165993., 104142., 110982., 117918., 124950.,
      86238.,  93270.,  100398., 107622., 150117., 160953., 171933., 183057.,
      154941., 166065., 177333., 188745., 118542., 126150., 133854., 141654.,
      97566.,  105366., 113262., 121254., 169413., 181401., 193533., 205809.,
      174237., 186513., 198933., 211497., 132942., 141318., 149790., 158358.,
      108894., 117462., 126126., 134886., 188709., 201849., 215133., 228561.,
      193533., 206961., 220533., 234249., 147342., 156486., 165726., 175062.,
      111716., 117876., 124100., 130388., 185830., 195262., 204790., 214414.,
      190198., 199822., 209542., 219358., 139908., 146452., 153060., 159732.,
      55108.,  61908.,  68772.,  75700.,  102838., 113230., 123718., 134302.,
      104902., 115486., 126166., 136942., 84324.,  91508.,  98756.,  106068.,
      142878., 153750., 164718., 175782., 246597., 263193., 279933., 296817.,
      251421., 268305., 285333., 302505., 190542., 201990., 213534., 225174.,
      154206., 165846., 177582., 189414., 265893., 283641., 301533., 319569.,
      270717., 288753., 306933., 325257., 204942., 217158., 229470., 241878.,
      165534., 177942., 190446., 203046., 285189., 304089., 323133., 342321.,
      290013., 309201., 328533., 348009., 219342., 232326., 245406., 258582.,
      176862., 190038., 203310., 216678., 304485., 324537., 344733., 365073.,
      309309., 329649., 350133., 370761., 233742., 247494., 261342., 275286.,
      175460., 184692., 193988., 203348., 290662., 304702., 318838., 333070.,
      295030., 309262., 323590., 338014., 215940., 225556., 235236., 244980.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    61.,    113.,   58.,    162.,   298.,   466.,   234.,
      402.,   602.,   834.,   333.,   449.,   581.,   729.,   130.,   330.,
      562.,   826.,   996.,   1524.,  2116.,  2772.,  1860.,  2516.,  3236.,
      4020.,  1682.,  2074.,  2498.,  2954.,  1143.,  1683.,  2271.,  2907.,
      4350.,  5622.,  6990.,  8454.,  6414.,  7878.,  9438.,  11094., 4815.,
      5643.,  6519.,  7443.,  3591.,  4323.,  5103.,  5931.,  10014., 11670.,
      13422., 15270., 13614., 15462., 17406., 19446., 8799.,  9819.,  10887.,
      12003., 5842.,  6490.,  7170.,  7882.,  14212., 15636., 17124., 18676.,
      17124., 18676., 20292., 21972., 10210., 11050., 11922., 12826., 4901.,
      5305.,  5725.,  6161.,  11386., 12258., 13162., 14098., 13098., 14034.,
      15002., 16002., 7533.,  8033.,  8549.,  9081.,  197.,   473.,   765.,
      1073.,  1466.,  2082.,  2730.,  3410.,  3690.,  4370.,  5082.,  5826.,
      2573.,  2945.,  3333.,  3737.,  3586.,  4298.,  5042.,  5818.,  9956.,
      11508., 13124., 14804., 14916., 16596., 18340., 20148., 9234.,  10138.,
      11074., 12042., 10935., 12243., 13599., 15003., 27006., 29814., 32718.,
      35718., 35214., 38214., 41310., 44502., 20751., 22347., 23991., 25683.,
      13383., 14883., 16431., 18027., 32670., 35862., 39150., 42534., 42414.,
      45798., 49278., 52854., 24735., 26523., 28359., 30243., 15442., 16602.,
      17794., 19018., 35460., 37908., 40420., 42996., 42468., 45044., 47684.,
      50388., 23906., 25258., 26642., 28058., 11237., 11897., 12573., 13265.,
      25082., 26466., 27882., 29330., 28842., 30290., 31770., 33282., 15917.,
      16673., 17445., 18233., 389.,   921.,   1469.,  2033.,  2874.,  4002.,
      5162.,  6354.,  7146.,  8338.,  9562.,  10818., 4813.,  5441.,  6085.,
      6745.,  7042.,  8266.,  9522.,  10810., 18916., 21492., 24132., 26836.,
      27972., 30676., 33444., 36276., 16786., 18202., 19650., 21130., 20727.,
      22803., 24927., 27099., 49662., 54006., 58446., 62982., 64014., 68550.,
      73182., 77910., 36687., 39051., 41463., 43923., 23175., 25443., 27759.,
      30123., 55326., 60054., 64878., 69798., 71214., 76134., 81150., 86262.,
      40671., 43227., 45831., 48483., 25042., 26714., 28418., 30154., 56708.,
      60180., 63716., 67316., 67812., 71412., 75076., 78804., 37602., 39466.,
      41362., 43290., 17573., 18489., 19421., 20369., 38778., 40674., 42602.,
      44562., 44586., 46546., 48538., 50562., 24301., 25313., 26341., 27385.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10168.,   15352.,   21048.,   27256.,   29012.,   38324.,   48404.,
      59252.,   45332.,   56180.,   67796.,   80180.,   46904.,   55160.,
      63928.,   73208.,   53940.,   67092.,   81012.,   95700.,   117678.,
      139710.,  162894.,  187230.,  155982.,  180318.,  205806.,  232446.,
      139764.,  157524.,  176052.,  195348.,  143796.,  163092.,  183156.,
      203988.,  270894.,  302142.,  334542.,  368094.,  309198.,  342750.,
      377454.,  413310.,  254196.,  278100.,  302772.,  328212.,  233652.,
      259092.,  285300.,  312276.,  424110.,  464574.,  506190.,  548958.,
      462414.,  505182.,  549102.,  594174.,  368628.,  398676.,  429492.,
      461076.,  323508.,  355092.,  387444.,  420564.,  577326.,  627006.,
      677838.,  729822.,  615630.,  667614.,  720750.,  775038.,  483060.,
      519252.,  556212.,  593940.,  380728.,  405368.,  430520.,  456184.,
      643220.,  681716.,  720980.,  761012.,  677972.,  718004.,  758804.,
      800372.,  507576.,  535288.,  563512.,  592248.,  222136.,  251896.,
      282168.,  312952.,  420692.,  466868.,  513812.,  561524.,  437012.,
      484724.,  533204.,  582452.,  357176.,  390008.,  423352.,  457208.,
      593076.,  643092.,  693876.,  745428.,  1036974., 1114302., 1192782.,
      1272414., 1075278., 1154910., 1235694., 1317630., 826356.,  880980.,
      936372.,  992532.,  682932.,  739092.,  796020.,  853716.,  1190190.,
      1276734., 1364430., 1453278., 1228494., 1317342., 1407342., 1498494.,
      940788.,  1001556., 1063092., 1125396., 772788.,  835092.,  898164.,
      962004.,  1343406., 1439166., 1536078., 1634142., 1381710., 1479774.,
      1578990., 1679358., 1055220., 1122132., 1189812., 1258260., 862644.,
      931092.,  1000308., 1070292., 1496622., 1601598., 1707726., 1815006.,
      1534926., 1642206., 1750638., 1860222., 1169652., 1242708., 1316532.,
      1391124., 887608.,  936824.,  986552.,  1036792., 1477268., 1552628.,
      1628756., 1705652., 1512020., 1588916., 1666580., 1745012., 1112760.,
      1165048., 1217848., 1271160., 434104.,  488440.,  543288.,  598648.,
      812372.,  895412.,  979220.,  1063796., 828692.,  913268.,  998612.,
      1084724., 667448.,  724856.,  782776.,  841208.,  1132212., 1219092.,
      1306740., 1395156., 1956270., 2088894., 2222670., 2357598., 1994574.,
      2129502., 2265582., 2402814., 1512948., 1604436., 1696692., 1789716.,
      1222068., 1315092., 1408884., 1503444., 2109486., 2251326., 2394318.,
      2538462., 2147790., 2291934., 2437230., 2583678., 1627380., 1725012.,
      1823412., 1922580., 1311924., 1411092., 1511028., 1611732., 2262702.,
      2413758., 2565966., 2719326., 2301006., 2454366., 2608878., 2764542.,
      1741812., 1845588., 1950132., 2055444., 1401780., 1507092., 1613172.,
      1720020., 2415918., 2576190., 2737614., 2900190., 2454222., 2616798.,
      2780526., 2945406., 1856244., 1966164., 2076852., 2188308., 1394488.,
      1468280., 1542584., 1617400., 2311316., 2423540., 2536532., 2650292.,
      2346068., 2459828., 2574356., 2689652., 1717944., 1794808., 1872184.,
      1950072.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    446.,    846.,    380.,    1180.,   2236.,   3548.,
      1724.,   3036.,   4604.,   6428.,   2558.,   3470.,   4510.,   5678.,
      860.,    2428.,   4252.,   6332.,   7480.,   11640.,  16312.,  21496.,
      14264.,  19448.,  25144.,  31352.,  13084.,  16188.,  19548.,  23164.,
      8634.,   12906.,  17562.,  22602.,  33588.,  43668.,  54516.,  66132.,
      49908.,  61524.,  73908.,  87060.,  37722.,  44298.,  51258.,  58602.,
      28026.,  33834.,  40026.,  46602.,  78516.,  91668.,  105588., 120276.,
      107124., 121812., 137268., 153492., 69402.,  77514.,  86010.,  94890.,
      46108.,  51260.,  56668.,  62332.,  112312., 123640., 135480., 147832.,
      135480., 147832., 160696., 174072., 80860.,  87548.,  94492.,  101692.,
      38814.,  42030.,  45374.,  48846.,  90236.,  97180.,  104380., 111836.,
      103868., 111324., 119036., 127004., 59774.,  63758.,  67870.,  72110.,
      1310.,   3502.,   5822.,   8270.,   11132.,  16028.,  21180.,  26588.,
      28860.,  34268.,  39932.,  45852.,  20222.,  23182.,  26270.,  29486.,
      27996.,  33660.,  39580.,  45756.,  78136.,  90488.,  103352., 116728.,
      117688., 131064., 144952., 159352., 72988.,  80188.,  87644.,  95356.,
      86202.,  96618.,  107418., 118602., 213300., 235668., 258804., 282708.,
      278772., 302676., 327348., 352788., 164442., 177162., 190266., 203754.,
      105594., 117546., 129882., 142602., 258228., 283668., 309876., 336852.,
      335988., 362964., 390708., 419220., 196122., 210378., 225018., 240042.,
      122396., 131644., 141148., 150908., 281272., 300792., 320824., 341368.,
      337208., 357752., 378808., 400376., 189916., 200700., 211740., 223036.,
      89246.,  94510.,  99902.,  105422., 199292., 210332., 221628., 233180.,
      229308., 240860., 252668., 264732., 126590., 132622., 138782., 145070.,
      2590.,   6830.,   11198.,  15694.,  21884.,  30876.,  40124.,  49628.,
      55996.,  65500.,  75260.,  85276.,  37886.,  42894.,  48030.,  53294.,
      55132.,  64892.,  74908.,  85180.,  148792., 169336., 190392., 211960.,
      221112., 242680., 264760., 287352., 132892., 144188., 155740., 167548.,
      163770., 180330., 197274., 214602., 393012., 427668., 463092., 499284.,
      507636., 543828., 580788., 618516., 291162., 310026., 329274., 348906.,
      183162., 201258., 219738., 238602., 437940., 475668., 514164., 553428.,
      564852., 604116., 644148., 684948., 322842., 343242., 364026., 385194.,
      198684., 212028., 225628., 239484., 450232., 477944., 506168., 534904.,
      538936., 567672., 596920., 626680., 298972., 313852., 328988., 344380.,
      139678., 146990., 154430., 161998., 308348., 323484., 338876., 354524.,
      354748., 370396., 386300., 402460., 193406., 201486., 209694., 218030.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32.,   68.,   89.,   110.,  96.,   114.,  219.,  264.,  309.,  252.,
      249.,  444.,  489.,  534.,  417.,  384.,  669.,  714.,  759.,  582.,
      519.,  894.,  939.,  984.,  747.,  560.,  929.,  968.,  1007., 740.,
      392.,  698.,  719.,  740.,  576.,  924.,  1569., 1614., 1659., 1242.,
      1059., 1794., 1839., 1884., 1407., 1194., 2019., 2064., 2109., 1572.,
      1329., 2244., 2289., 2334., 1737., 1280., 2099., 2138., 2177., 1580.,
      752.,  1328., 1349., 1370., 1056., 1734., 2919., 2964., 3009., 2232.,
      1869., 3144., 3189., 3234., 2397., 2004., 3369., 3414., 3459., 2562.,
      2139., 3594., 3639., 3684., 2727., 2000., 3269., 3308., 3347., 2420.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,   4.,   10.,   12.,  9.,   8.,   26.,  56.,   54.,   36.,
      30.,  84.,  165.,  144., 90.,  66.,  165., 300.,  243.,  144.,
      89.,  206., 353.,  270., 153., 70.,  157., 262.,  195.,  108.,
      13.,  40.,  82.,   72.,  45.,  68.,  170., 308.,  246.,  144.,
      174., 408., 705.,  540., 306., 210., 489., 840.,  639.,  360.,
      221., 494., 821.,  606., 333., 154., 337., 550.,  399.,  216.,
      25.,  76.,  154.,  132., 81.,  128., 314., 560.,  438.,  252.,
      318., 732., 1245., 936., 522., 354., 813., 1380., 1035., 576.,
      353., 782., 1289., 942., 513., 238., 517., 838.,  603.,  324.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      204.,   454.,   610.,   766.,   684.,   786.,   1545.,  1887.,  2229.,
      1842.,  1806.,  3255.,  3597.,  3939.,  3102.,  2826.,  4965.,  5307.,
      5649.,  4362.,  3846.,  6675.,  7017.,  7359.,  5622.,  4244.,  7066.,
      7366.,  7666.,  5652.,  2844.,  5134.,  5290.,  5446.,  4284.,  6906.,
      11805., 12147., 12489., 9402.,  7926.,  13515., 13857., 14199., 10662.,
      8946.,  15225., 15567., 15909., 11922., 9966.,  16935., 17277., 17619.,
      13182., 9764.,  16066., 16366., 16666., 12132., 5484.,  9814.,  9970.,
      10126., 7884.,  13026., 22065., 22407., 22749., 16962., 14046., 23775.,
      24117., 24459., 18222., 15066., 25485., 25827., 26169., 19482., 16086.,
      27195., 27537., 27879., 20742., 15284., 25066., 25366., 25666., 18612.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,    22.,   59.,   78.,   61.,   46.,   164.,  370.,   372.,  254.,
      195.,  570.,  1149., 1026., 651.,  465.,  1182., 2175.,  1782., 1065.,
      658.,  1532., 2638., 2028., 1154., 527.,  1186., 1985.,  1482., 823.,
      77.,   262.,  563.,  510.,  325.,  478.,  1220., 2242.,  1812., 1070.,
      1275., 3018., 5253., 4050., 2307., 1545., 3630., 6279.,  4806., 2721.,
      1666., 3740., 6238., 4620., 2546., 1175., 2578., 4217.,  3066., 1663.,
      149.,  502.,  1067., 942.,  589.,  910.,  2276., 4114.,  3252., 1886.,
      2355., 5466., 9357., 7074., 3963., 2625., 6078., 10383., 7830., 4377.,
      2674., 5948., 9838., 7212., 3938., 1823., 3970., 6449.,  4650., 2503.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432.,   3284.,   4484.,   5684.,   5144.,   5796.,   11550.,  14214.,
      16878.,  14052.,  13716.,  24870.,  27534.,  30198.,  23892.,  21636.,
      38190.,  40854.,  43518.,  33732.,  29556.,  51510.,  54174.,  56838.,
      43572.,  33016.,  55076.,  57428.,  59780.,  44152.,  21592.,  39284.,
      40484.,  41684.,  32984.,  53316.,  91470.,  94134.,  96798.,  73092.,
      61236.,  104790., 107454., 110118., 82932.,  69156.,  118110., 120774.,
      123438., 92772.,  77076.,  131430., 134094., 136758., 102612., 76216.,
      125636., 127988., 130340., 95032.,  41752.,  75284.,  76484.,  77684.,
      60824.,  100836., 171390., 174054., 176718., 132132., 108756., 184710.,
      187374., 190038., 141972., 116676., 198030., 200694., 203358., 151812.,
      124596., 211350., 214014., 216678., 161652., 119416., 196196., 198548.,
      200900., 145912.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,   556.,   446.,   300.,   1144.,  2660.,  2744.,
      1900.,  1386.,  4164.,  8526.,  7716.,  4938.,  3474.,  8916.,  16518.,
      13620., 8178.,  5052.,  11800., 20372., 15704., 8956.,  4086.,  9212.,
      15442., 11548., 6422.,  510.,   1868.,  4138.,  3820.,  2462.,  3564.,
      9208.,  17060., 13880., 8236.,  9738.,  23172., 40494., 31332., 17898.,
      11826., 27924., 48486., 37236., 21138., 12924., 29080., 48596., 36056.,
      19900., 9174.,  20156., 33010., 24028., 13046., 990.,   3596.,  7882.,
      7084.,  4478.,  6828.,  17272., 31460., 25016., 14572., 18090., 42180.,
      72462., 54948., 30858., 20178., 46932., 80454., 60852., 34098., 20796.,
      46360., 76820., 56408., 30844., 14262., 31100., 50578., 36508., 19670.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76.,    128.,   182.,   272.,   254.,   356.,   326.,   440.,   300.,
      384.,   330.,   456.,   669.,   876.,   831.,   1056.,  993.,   1236.,
      834.,   1008.,  810.,   996.,   1479.,  1776.,  1641.,  1956.,  1803.,
      2136.,  1434.,  1668.,  1290.,  1536.,  2289.,  2676.,  2451.,  2856.,
      2613.,  3036.,  2034.,  2328.,  1770.,  2076.,  3099.,  3576.,  3261.,
      3756.,  3423.,  3936.,  2634.,  2988.,  2004.,  2240.,  3350.,  3716.,
      3494.,  3872.,  3638.,  4028.,  2692.,  2960.,  1276.,  1568.,  2342.,
      2792.,  2414.,  2876.,  2486.,  2960.,  1980.,  2304.,  3210.,  3696.,
      5529.,  6276.,  5691.,  6456.,  5853.,  6636.,  4434.,  4968.,  3690.,
      4236.,  6339.,  7176.,  6501.,  7356.,  6663.,  7536.,  5034.,  5628.,
      4170.,  4776.,  7149.,  8076.,  7311.,  8256.,  7473.,  8436.,  5634.,
      6288.,  4650.,  5316.,  7959.,  8976.,  8121.,  9156.,  8283.,  9336.,
      6234.,  6948.,  4644.,  5120.,  7670.,  8396.,  7814.,  8552.,  7958.,
      8708.,  5812.,  6320.,  2476.,  3008.,  4502.,  5312.,  4574.,  5396.,
      4646.,  5480.,  3660.,  4224.,  6090.,  6936.,  10389., 11676., 10551.,
      11856., 10713., 12036., 8034.,  8928.,  6570.,  7476.,  11199., 12576.,
      11361., 12756., 11523., 12936., 8634.,  9588.,  7050.,  8016.,  12009.,
      13476., 12171., 13656., 12333., 13836., 9234.,  10248., 7530.,  8556.,
      12819., 14376., 12981., 14556., 13143., 14736., 9834.,  10908., 7284.,
      8000.,  11990., 13076., 12134., 13232., 12278., 13388., 8932.,  9680.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    6.,    16.,   19.,   40.,   30.,   48.,   25.,   36.,
      14.,   32.,   60.,   104.,  146.,  224.,  156.,  216.,  110.,  144.,
      75.,   120.,  234.,  336.,  489.,  660.,  450.,  576.,  291.,  360.,
      201.,  264.,  522.,  660.,  975.,  1200., 810.,  972.,  489.,  576.,
      302.,  356.,  708.,  824.,  1226., 1412., 948.,  1080., 542.,  612.,
      247.,  280.,  558.,  628.,  937.,  1048., 702.,  780.,  391.,  432.,
      25.,   52.,   102.,  160.,  235.,  328.,  222.,  288.,  145.,  180.,
      206.,  272.,  540.,  680.,  1010., 1232., 828.,  984.,  494.,  576.,
      579.,  696.,  1386., 1632., 2433., 2820., 1890., 2160., 1083., 1224.,
      705.,  840.,  1674., 1956., 2919., 3360., 2250., 2556., 1281., 1440.,
      782.,  884.,  1764., 1976., 2954., 3284., 2196., 2424., 1214., 1332.,
      559.,  616.,  1230., 1348., 2017., 2200., 1470., 1596., 799.,  864.,
      49.,   100.,  198.,  304.,  451.,  616.,  414.,  528.,  265.,  324.,
      398.,  512.,  1020., 1256., 1874., 2240., 1500., 1752., 878.,  1008.,
      1083., 1272., 2538., 2928., 4377., 4980., 3330., 3744., 1875., 2088.,
      1209., 1416., 2826., 3252., 4863., 5520., 3690., 4140., 2073., 2304.,
      1262., 1412., 2820., 3128., 4682., 5156., 3444., 3768., 1886., 2052.,
      871.,  952.,  1902., 2068., 3097., 3352., 2238., 2412., 1207., 1296.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      516.,   916.,    1294.,  1990.,   1846.,   2638.,   2398.,   3286.,
      2244.,  2900.,   2406.,  3390.,   4965.,   6585.,   6225.,   7989.,
      7485.,  9393.,   6342.,  7710.,   6126.,   7590.,   11265.,  13605.,
      12525., 15009.,  13785., 16413.,  11022.,  12870.,  9846.,   11790.,
      17565., 20625.,  18825., 22029.,  20085.,  23433.,  15702.,  18030.,
      13566., 15990.,  23865., 27645.,  25125.,  29049.,  26385.,  30453.,
      20382., 23190.,  15572., 17444.,  26086.,  28990.,  27214.,  30214.,
      28342., 31438.,  21012., 23140.,  9636.,   11956.,  17854.,  21430.,
      18406., 22078.,  18958., 22726.,  15204.,  17780.,  24726.,  28590.,
      42765., 48705.,  44025., 50109.,  45285.,  51513.,  34422.,  38670.,
      28446., 32790.,  49065., 55725.,  50325.,  57129.,  51585.,  58533.,
      39102., 43830.,  32166., 36990.,  55365.,  62745.,  56625.,  64149.,
      57885., 65553.,  43782., 48990.,  35886.,  41190.,  61665.,  69765.,
      62925., 71169.,  64185., 72573.,  48462.,  54150.,  36212.,  40004.,
      59926., 65710.,  61054., 66934.,  62182.,  68158.,  45492.,  49540.,
      18756., 22996.,  34414., 40870.,  34966.,  41518.,  35518.,  42166.,
      28164., 32660.,  47046., 53790.,  80565.,  90825.,  81825.,  92229.,
      83085., 93633.,  62502., 69630.,  50766.,  57990.,  86865.,  97845.,
      88125., 99249.,  89385., 100653., 67182.,  74790.,  54486.,  62190.,
      93165., 104865., 94425., 106269., 95685.,  107673., 71862.,  79950.,
      58206., 66390.,  99465., 111885., 100725., 113289., 101985., 114693.,
      76542., 85110.,  56852., 62564.,  93766.,  102430., 94894.,  103654.,
      96022., 104878., 69972., 75940.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    34.,    106.,   119.,   275.,   210.,   346.,   181.,
      265.,   82.,    218.,   404.,   740.,   1030.,  1630.,  1140.,  1604.,
      818.,   1082.,  519.,   867.,   1686.,  2478.,  3597.,  4929.,  3366.,
      4350.,  2199.,  2739.,  1491.,  1983.,  3918.,  4998.,  7377.,  9141.,
      6174.,  7446.,  3747.,  4431.,  2314.,  2738.,  5444.,  6356.,  9454.,
      10918., 7332.,  8372.,  4202.,  4754.,  1913.,  2173.,  4330.,  4882.,
      7283.,  8159.,  5466.,  6082.,  3049.,  3373.,  149.,   361.,   706.,
      1162.,  1703.,  2435.,  1650.,  2170.,  1093.,  1369.,  1522.,  2042.,
      4052.,  5156.,  7654.,  9406.,  6324.,  7556.,  3794.,  4442.,  4407.,
      5331.,  10614., 12558., 18717., 21777., 14598., 16734., 8391.,  9507.,
      5379.,  6447.,  12846., 15078., 22497., 25989., 17406., 19830., 9939.,
      11199., 6058.,  6866.,  13700., 15380., 22990., 25606., 17124., 18932.,
      9482.,  10418., 4361.,  4813.,  9610.,  10546., 15779., 17231., 11514.,
      12514., 6265.,  6781.,  293.,   697.,   1378.,  2218.,  3287.,  4595.,
      3090.,  3994.,  2005.,  2473.,  2962.,  3866.,  7700.,  9572.,  14278.,
      17182., 11508., 13508., 6770.,  7802.,  8295.,  9795.,  19542., 22638.,
      33837., 38625., 25830., 29118., 14583., 16275., 9267.,  10911., 21774.,
      25158., 37617., 42837., 28638., 32214., 16131., 17967., 9802.,  10994.,
      21956., 24404., 36526., 40294., 26916., 29492., 14762., 16082., 6809.,
      7453.,  14890., 16210., 24275., 26303., 17562., 18946., 9481.,  10189.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3768.,   6904.,   9716.,   15188.,  14036.,  20276.,  18356.,  25364.,
      17336.,  22520.,  18324.,  26100.,  38190.,  51006.,  48126.,  62094.,
      58062.,  73182.,  49428.,  60276.,  47604.,  59220.,  87870.,  106446.,
      97806.,  117534., 107742., 128622., 86388.,  101076., 76884.,  92340.,
      137550., 161886., 147486., 172974., 157422., 184062., 123348., 141876.,
      106164., 125460., 187230., 217326., 197166., 228414., 207102., 239502.,
      160308., 182676., 122744., 137656., 205844., 228980., 214772., 238676.,
      223700., 248372., 166008., 182968., 74808.,  93304.,  139316., 167828.,
      143636., 172916., 147956., 178004., 119096., 139640., 194004., 224820.,
      336270., 383646., 346206., 394734., 356142., 405822., 271188., 305076.,
      223284., 257940., 385950., 439086., 395886., 450174., 405822., 461262.,
      308148., 345876., 252564., 291060., 435630., 494526., 445566., 505614.,
      455502., 516702., 345108., 386676., 281844., 324180., 485310., 549966.,
      495246., 561054., 505182., 572142., 382068., 427476., 285944., 316216.,
      473684., 519860., 482612., 529556., 491540., 539252., 359928., 392248.,
      145848., 179704., 268916., 320468., 273236., 325556., 277556., 330644.,
      220856., 256760., 369684., 423540., 634350., 716286., 644286., 727374.,
      654222., 738462., 492948., 549876., 398964., 456660., 684030., 771726.,
      693966., 782814., 703902., 793902., 529908., 590676., 428244., 489780.,
      733710., 827166., 743646., 838254., 753582., 849342., 566868., 631476.,
      457524., 522900., 783390., 882606., 793326., 893694., 803262., 904782.,
      603828., 672276., 449144., 494776., 741524., 810740., 750452., 820436.,
      759380., 830132., 553848., 601528.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    220.,    764.,    826.,    2026.,   1564.,   2620.,
      1374.,   2030.,   540.,    1596.,   2936.,   5560.,   7700.,   12404.,
      8696.,   12344.,  6300.,   8380.,   3834.,   6570.,   12756.,  18996.,
      27534.,  38046.,  26004.,  33780.,  17082.,  21354.,  11466.,  15354.,
      30324.,  38868.,  57342.,  71310.,  48180.,  58260.,  29322.,  34746.,
      18108.,  21468.,  42680.,  49912.,  74228.,  85844.,  57656.,  65912.,
      33084.,  37468.,  15054.,  17118.,  34108.,  38492.,  57418.,  64378.,
      43132.,  48028.,  24078.,  26654.,  990.,    2670.,   5212.,   8828.,
      12922.,  18730.,  12700.,  16828.,  8478.,   10670.,  11676.,  15804.,
      31352.,  40120.,  59540.,  73460.,  49400.,  59192.,  29724.,  34876.,
      34362.,  41706.,  83028.,  98484.,  146766., 171102., 114708., 131700.,
      66042.,  74922.,  41994.,  50490.,  100596., 118356., 176574., 204366.,
      136884., 156180., 78282.,  88314.,  47676.,  54108.,  107960., 121336.,
      181364., 202196., 135224., 149624., 74940.,  82396.,  34446.,  38046.,
      75964.,  83420.,  124810., 136378., 91132.,  99100.,  49614.,  53726.,
      1950.,   5166.,   10204.,  16892.,  25018.,  35434.,  23836.,  31036.,
      15582.,  19310.,  22812.,  30012.,  59768.,  74680.,  111380., 134516.,
      90104.,  106040., 53148.,  61372.,  64890.,  76842.,  153300., 177972.,
      265998., 304158., 203412., 229620., 115002., 128490., 72522.,  85626.,
      170868., 197844., 295806., 337422., 225588., 254100., 127242., 141882.,
      77244.,  86748.,  173240., 192760., 288500., 318548., 212792., 233336.,
      116796., 127324., 53838.,  58974.,  117820., 128348., 192202., 208378.,
      139132., 150172., 75150.,  80798.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      212.,   304.,   404.,   512.,   566.,   728.,   902.,   1088.,  830.,
      1016.,  1214.,  1424.,  1094.,  1304.,  1526.,  1760.,  1044.,  1200.,
      1364.,  1536.,  1086.,  1320.,  1566.,  1824.,  2289.,  2676.,  3081.,
      3504.,  2901.,  3324.,  3765.,  4224.,  3513.,  3972.,  4449.,  4944.,
      3006.,  3336.,  3678.,  4032.,  2886.,  3240.,  3606.,  3984.,  5349.,
      5916.,  6501.,  7104.,  5961.,  6564.,  7185.,  7824.,  6573.,  7212.,
      7869.,  8544.,  5286.,  5736.,  6198.,  6672.,  4686.,  5160.,  5646.,
      6144.,  8409.,  9156.,  9921.,  10704., 9021.,  9804.,  10605., 11424.,
      9633.,  10452., 11289., 12144., 7566.,  8136.,  8718.,  9312.,  6486.,
      7080.,  7686.,  8304.,  11469., 12396., 13341., 14304., 12081., 13044.,
      14025., 15024., 12693., 13692., 14709., 15744., 9846.,  10536., 11238.,
      11952., 7556.,  8016.,  8484.,  8960.,  12686., 13400., 14126., 14864.,
      13238., 13976., 14726., 15488., 13790., 14552., 15326., 16112., 10244.,
      10768., 11300., 11840., 4532.,  5104.,  5684.,  6272.,  8486.,  9368.,
      10262., 11168., 8750.,  9656.,  10574., 11504., 9014.,  9944.,  10886.,
      11840., 7284.,  7920.,  8564.,  9216.,  11886., 12840., 13806., 14784.,
      20649., 22116., 23601., 25104., 21261., 22764., 24285., 25824., 21873.,
      23412., 24969., 26544., 16686., 17736., 18798., 19872., 13686., 14760.,
      15846., 16944., 23709., 25356., 27021., 28704., 24321., 26004., 27705.,
      29424., 24933., 26652., 28389., 30144., 18966., 20136., 21318., 22512.,
      15486., 16680., 17886., 19104., 26769., 28596., 30441., 32304., 27381.,
      29244., 31125., 33024., 27993., 29892., 31809., 33744., 21246., 22536.,
      23838., 25152., 17286., 18600., 19926., 21264., 29829., 31836., 33861.,
      35904., 30441., 32484., 34545., 36624., 31053., 33132., 35229., 37344.,
      23526., 24936., 26358., 27792., 17636., 18576., 19524., 20480., 29246.,
      30680., 32126., 33584., 29798., 31256., 32726., 34208., 30350., 31832.,
      33326., 34832., 22244., 23248., 24260., 25280., 8852.,  9904.,  10964.,
      12032., 16406., 18008., 19622., 21248., 16670., 18296., 19934., 21584.,
      16934., 18584., 20246., 21920., 13524., 14640., 15764., 16896., 22686.,
      24360., 26046., 27744., 39009., 41556., 44121., 46704., 39621., 42204.,
      44805., 47424., 40233., 42852., 45489., 48144., 30366., 32136., 33918.,
      35712., 24486., 26280., 28086., 29904., 42069., 44796., 47541., 50304.,
      42681., 45444., 48225., 51024., 43293., 46092., 48909., 51744., 32646.,
      34536., 36438., 38352., 26286., 28200., 30126., 32064., 45129., 48036.,
      50961., 53904., 45741., 48684., 51645., 54624., 46353., 49332., 52329.,
      55344., 34926., 36936., 38958., 40992., 28086., 30120., 32166., 34224.,
      48189., 51276., 54381., 57504., 48801., 51924., 55065., 58224., 49413.,
      52572., 55749., 58944., 37206., 39336., 41478., 43632., 27716., 29136.,
      30564., 32000., 45806., 47960., 50126., 52304., 46358., 48536., 50726.,
      52928., 46910., 49112., 51326., 53552., 34244., 35728., 37220., 38720.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,     4.,     9.,     16.,    10.,    24.,    42.,    64.,    43.,
      76.,    115.,   160.,   90.,    120.,   154.,   192.,   81.,    100.,
      121.,   144.,   26.,    56.,    90.,    128.,   164.,   240.,   324.,
      416.,   446.,   584.,   734.,   896.,   516.,   624.,   740.,   864.,
      378.,   440.,   506.,   576.,   219.,   300.,   387.,   480.,   750.,
      936.,   1134.,  1344.,  1641.,  1956.,  2289.,  2640.,  1566.,  1800.,
      2046.,  2304.,  1035.,  1164.,  1299.,  1440.,  687.,   804.,   927.,
      1056.,  1830.,  2088.,  2358.,  2640.,  3477.,  3900.,  4341.,  4800.,
      2934.,  3240.,  3558.,  3888.,  1791.,  1956.,  2127.,  2304.,  1106.,
      1208.,  1314.,  1424.,  2612.,  2832.,  3060.,  3296.,  4550.,  4904.,
      5270.,  5648.,  3540.,  3792.,  4052.,  4320.,  2034.,  2168.,  2306.,
      2448.,  925.,   988.,   1053.,  1120.,  2098.,  2232.,  2370.,  2512.,
      3535.,  3748.,  3967.,  4192.,  2658.,  2808.,  2962.,  3120.,  1485.,
      1564.,  1645.,  1728.,  49.,    100.,   153.,   208.,   298.,   408.,
      522.,   640.,   763.,   940.,   1123.,  1312.,  762.,   888.,   1018.,
      1152.,  513.,   580.,   649.,   720.,   698.,   824.,   954.,   1088.,
      1892.,  2160.,  2436.,  2720.,  3614.,  4040.,  4478.,  4928.,  3012.,
      3312.,  3620.,  3936.,  1818.,  1976.,  2138.,  2304.,  2091.,  2316.,
      2547.,  2784.,  5070.,  5544.,  6030.,  6528.,  8985.,  9732.,  10497.,
      11280., 7038.,  7560.,  8094.,  8640.,  4059.,  4332.,  4611.,  4896.,
      2559.,  2820.,  3087.,  3360.,  6150.,  6696.,  7254.,  7824.,  10821.,
      11676., 12549., 13440., 8406.,  9000.,  9606.,  10224., 4815.,  5124.,
      5439.,  5760.,  2930.,  3128.,  3330.,  3536.,  6644.,  7056.,  7476.,
      7904.,  11174., 11816., 12470., 13136., 8340.,  8784.,  9236.,  9696.,
      4626.,  4856.,  5090.,  5328.,  2125.,  2236.,  2349.,  2464.,  4690.,
      4920.,  5154.,  5392.,  7711.,  8068.,  8431.,  8800.,  5634.,  5880.,
      6130.,  6384.,  3069.,  3196.,  3325.,  3456.,  97.,    196.,   297.,
      400.,   586.,   792.,   1002.,  1216.,  1483.,  1804.,  2131.,  2464.,
      1434.,  1656.,  1882.,  2112.,  945.,   1060.,  1177.,  1296.,  1370.,
      1592.,  1818.,  2048.,  3620.,  4080.,  4548.,  5024.,  6782.,  7496.,
      8222.,  8960.,  5508.,  6000.,  6500.,  7008.,  3258.,  3512.,  3770.,
      4032.,  3963.,  4332.,  4707.,  5088.,  9390.,  10152., 10926., 11712.,
      16329., 17508., 18705., 19920., 12510., 13320., 14142., 14976., 7083.,
      7500.,  7923.,  8352.,  4431.,  4836.,  5247.,  5664.,  10470., 11304.,
      12150., 13008., 18165., 19452., 20757., 22080., 13878., 14760., 15654.,
      16560., 7839.,  8292.,  8751.,  9216.,  4754.,  5048.,  5346.,  5648.,
      10676., 11280., 11892., 12512., 17798., 18728., 19670., 20624., 13140.,
      13776., 14420., 15072., 7218.,  7544.,  7874.,  8208.,  3325.,  3484.,
      3645.,  3808.,  7282.,  7608.,  7938.,  8272.,  11887., 12388., 12895.,
      13408., 8610.,  8952.,  9298.,  9648.,  4653.,  4828.,  5005.,  5184.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1524.,   2244.,   3028.,   3876.,   4222.,   5494.,   6862.,   8326.,
      6286.,   7750.,   9310.,   10966.,  8350.,   10006.,  11758.,  13606.,
      8052.,   9284.,   10580.,  11940.,  8238.,   10086.,  12030.,  14070.,
      17565.,  20625.,  23829.,  27177.,  22389.,  25737.,  29229.,  32865.,
      27213.,  30849.,  34629.,  38553.,  23406.,  26022.,  28734.,  31542.,
      22398.,  25206.,  28110.,  31110.,  41685.,  46185.,  50829.,  55617.,
      46509.,  51297.,  56229.,  61305.,  51333.,  56409.,  61629.,  66993.,
      41406.,  44982.,  48654.,  52422.,  36558.,  40326.,  44190.,  48150.,
      65805.,  71745.,  77829.,  84057.,  70629.,  76857.,  83229.,  89745.,
      75453.,  81969.,  88629.,  95433.,  59406.,  63942.,  68574.,  73302.,
      50718.,  55446.,  60270.,  65190.,  89925.,  97305.,  104829., 112497.,
      94749.,  102417., 110229., 118185., 99573.,  107529., 115629., 123873.,
      77406.,  82902.,  88494.,  94182.,  59540.,  63204.,  66932.,  70724.,
      100078., 105766., 111550., 117430., 104446., 110326., 116302., 122374.,
      108814., 114886., 121054., 127318., 80916.,  85092.,  89332.,  93636.,
      35124.,  39684.,  44308.,  48996.,  66142.,  73174.,  80302.,  87526.,
      68206.,  75430.,  82750.,  90166.,  70270.,  77686.,  85198.,  92806.,
      57012.,  62084.,  67220.,  72420.,  93198.,  100806., 108510., 116310.,
      162285., 173985., 185829., 197817., 167109., 179097., 191229., 203505.,
      171933., 184209., 196629., 209193., 131406., 139782., 148254., 156822.,
      107358., 115926., 124590., 133350., 186405., 199545., 212829., 226257.,
      191229., 204657., 218229., 231945., 196053., 209769., 223629., 237633.,
      149406., 158742., 168174., 177702., 121518., 131046., 140670., 150390.,
      210525., 225105., 239829., 254697., 215349., 230217., 245229., 260385.,
      220173., 235329., 250629., 266073., 167406., 177702., 188094., 198582.,
      135678., 146166., 156750., 167430., 234645., 250665., 266829., 283137.,
      239469., 255777., 272229., 288825., 244293., 260889., 277629., 294513.,
      185406., 196662., 208014., 219462., 139220., 146724., 154292., 161924.,
      231118., 242566., 254110., 265750., 235486., 247126., 258862., 270694.,
      239854., 251686., 263614., 275638., 175956., 183972., 192052., 200196.,
      68724.,  77124.,  85588.,  94116.,  128062., 140854., 153742., 166726.,
      130126., 143110., 156190., 169366., 132190., 145366., 158638., 172006.,
      105972., 114884., 123860., 132900., 178158., 191526., 204990., 218550.,
      307005., 327345., 347829., 368457., 311829., 332457., 353229., 374145.,
      316653., 337569., 358629., 379833., 239406., 253542., 267774., 282102.,
      192318., 206646., 221070., 235590., 331125., 352905., 374829., 396897.,
      335949., 358017., 380229., 402585., 340773., 363129., 385629., 408273.,
      257406., 272502., 287694., 302982., 206478., 221766., 237150., 252630.,
      355245., 378465., 401829., 425337., 360069., 383577., 407229., 431025.,
      364893., 388689., 412629., 436713., 275406., 291462., 307614., 323862.,
      220638., 236886., 253230., 269670., 379365., 404025., 428829., 453777.,
      384189., 409137., 434229., 459465., 389013., 414249., 439629., 465153.,
      293406., 310422., 327534., 344742., 218900., 230244., 241652., 253124.,
      362158., 379366., 396670., 414070., 366526., 383926., 401422., 419014.,
      370894., 388486., 406174., 423958., 270996., 282852., 294772., 306756.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,      25.,     61.,     113.,    58.,     162.,    298.,    466.,
      287.,    539.,    839.,    1187.,   666.,    898.,    1162.,   1458.,
      613.,    761.,    925.,    1105.,   154.,    386.,    650.,    946.,
      1172.,   1764.,   2420.,   3140.,   3310.,   4390.,   5566.,   6838.,
      3924.,   4772.,   5684.,   6660.,   2906.,   3394.,   3914.,   4466.,
      1599.,   2235.,   2919.,   3651.,   5646.,   7110.,   8670.,   10326.,
      12525.,  15009.,  17637.,  20409.,  12078.,  13926.,  15870.,  17910.,
      8031.,   9051.,   10119.,  11235.,  5271.,   6195.,   7167.,   8187.,
      14142.,  16182.,  18318.,  20550.,  26997.,  30345.,  33837.,  37473.,
      22878.,  25302.,  27822.,  30438.,  14007.,  15315.,  16671.,  18075.,
      8650.,   9458.,   10298.,  11170.,  20468.,  22212.,  24020.,  25892.,
      35710.,  38518.,  41422.,  44422.,  27828.,  29828.,  31892.,  34020.,
      16010.,  17074.,  18170.,  19298.,  7277.,   7777.,   8293.,   8825.,
      16522.,  17586.,  18682.,  19810.,  27863.,  29555.,  31295.,  33083.,
      20970.,  22162.,  23386.,  24642.,  11725.,  12353.,  12997.,  13657.,
      293.,    697.,    1117.,   1553.,   2170.,   3042.,   3946.,   4882.,
      5759.,   7163.,   8615.,   10115.,  5850.,   6850.,   7882.,   8946.,
      3973.,   4505.,   5053.,   5617.,   5338.,   6338.,   7370.,   8434.,
      14612.,  16740.,  18932.,  21188.,  28078.,  31462.,  34942.,  38518.,
      23508.,  25892.,  28340.,  30852.,  14234.,  15490.,  16778.,  18098.,
      16287.,  18075.,  19911.,  21795.,  39630.,  43398.,  47262.,  51222.,
      70413.,  76353.,  82437.,  88665.,  55278.,  59430.,  63678.,  68022.,
      31935.,  34107.,  36327.,  38595.,  19959.,  22035.,  24159.,  26331.,
      48126.,  52470.,  56910.,  61446.,  84885.,  91689.,  98637.,  105729.,
      66078.,  70806.,  75630.,  80550.,  37911.,  40371.,  42879.,  45435.,
      23050.,  24626.,  26234.,  27874.,  52340.,  55620.,  58964.,  62372.,
      88126.,  93238.,  98446.,  103750., 65844.,  69380.,  72980.,  76644.,
      36554.,  38386.,  40250.,  42146.,  16781.,  17665.,  18565.,  19481.,
      37066.,  38898.,  40762.,  42658.,  60983.,  63827.,  66719.,  69659.,
      44586.,  46546.,  48538.,  50562.,  24301.,  25313.,  26341.,  27385.,
      581.,    1369.,   2173.,   2993.,   4282.,   5922.,   7594.,   9298.,
      11231.,  13787.,  16391.,  19043.,  11034.,  12802.,  14602.,  16434.,
      7333.,   8249.,   9181.,   10129.,  10522.,  12290.,  14090.,  15922.,
      28052.,  31716.,  35444.,  39236.,  52846.,  58534.,  64318.,  70198.,
      43092.,  47012.,  50996.,  55044.,  25562.,  27586.,  29642.,  31730.,
      30975.,  33915.,  36903.,  39939.,  73614.,  79686.,  85854.,  92118.,
      128301., 137697., 147237., 156921., 98478.,  104934., 111486., 118134.,
      55839.,  59163.,  62535.,  65955.,  34647.,  37875.,  41151.,  44475.,
      82110.,  88758.,  95502.,  102342., 142773., 153033., 163437., 173985.,
      109278., 116310., 123438., 130662., 61815.,  65427.,  69087.,  72795.,
      37450.,  39794.,  42170.,  44578.,  84212.,  89028.,  93908.,  98852.,
      140542., 147958., 155470., 163078., 103860., 108932., 114068., 119268.,
      57098.,  59698.,  62330.,  64994.,  26285.,  27553.,  28837.,  30137.,
      57610.,  60210.,  62842.,  65506.,  94103.,  98099.,  102143., 106235.,
      68202.,  70930.,  73690.,  76482.,  36877.,  38273.,  39685.,  41113.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11512.,   17208.,   23416.,   30136.,   32564.,   42644.,   53492.,
      65108.,   48884.,   60500.,   72884.,   86036.,   65204.,   78356.,
      92276.,   106964.,  63224.,   73016.,   83320.,   94136.,   64116.,
      78804.,   94260.,   110484.,  137550.,  161886.,  187374.,  214014.,
      175854.,  202494.,  230286.,  259230.,  214158.,  243102.,  273198.,
      304446.,  184692.,  205524.,  227124.,  249492.,  176436.,  198804.,
      221940.,  245844.,  329070.,  364926.,  401934.,  440094.,  367374.,
      405534.,  444846.,  485310.,  405678.,  446142.,  487758.,  530526.,
      327732.,  356244.,  385524.,  415572.,  288756.,  318804.,  349620.,
      381204.,  520590.,  567966.,  616494.,  666174.,  558894.,  608574.,
      659406.,  711390.,  597198.,  649182.,  702318.,  756606.,  470772.,
      506964.,  543924.,  581652.,  401076.,  438804.,  477300.,  516564.,
      712110.,  771006.,  831054.,  892254.,  750414.,  811614.,  873966.,
      937470.,  788718.,  852222.,  916878.,  982686.,  613812.,  657684.,
      702324.,  747732.,  472696.,  501944.,  531704.,  561976.,  794996.,
      840404.,  886580.,  933524.,  829748.,  876692.,  924404.,  972884.,
      864500.,  912980.,  962228.,  1012244., 643192.,  676536.,  710392.,
      744760.,  276472.,  312888.,  349816.,  387256.,  522164.,  578324.,
      635252.,  692948.,  538484.,  596180.,  654644.,  713876.,  554804.,
      614036.,  674036.,  734804.,  451064.,  491576.,  532600.,  574136.,
      738036.,  798804.,  860340.,  922644.,  1286670., 1380126., 1474734.,
      1570494., 1324974., 1420734., 1517646., 1615710., 1363278., 1461342.,
      1560558., 1660926., 1042932., 1109844., 1177524., 1245972., 850356.,
      918804.,  988020.,  1058004., 1478190., 1583166., 1689294., 1796574.,
      1516494., 1623774., 1732206., 1841790., 1554798., 1664382., 1775118.,
      1887006., 1185972., 1260564., 1335924., 1412052., 962676.,  1038804.,
      1115700., 1193364., 1669710., 1786206., 1903854., 2022654., 1708014.,
      1826814., 1946766., 2067870., 1746318., 1867422., 1989678., 2113086.,
      1329012., 1411284., 1494324., 1578132., 1074996., 1158804., 1243380.,
      1328724., 1861230., 1989246., 2118414., 2248734., 1899534., 2029854.,
      2161326., 2293950., 1937838., 2070462., 2204238., 2339166., 1472052.,
      1562004., 1652724., 1744212., 1106296., 1166264., 1226744., 1287736.,
      1837556., 1929044., 2021300., 2114324., 1872308., 1965332., 2059124.,
      2153684., 1907060., 2001620., 2096948., 2193044., 1399672., 1463736.,
      1528312., 1593400., 541432.,  608568.,  676216.,  744376.,  1011764.,
      1114004., 1217012., 1320788., 1028084., 1131860., 1236404., 1341716.,
      1044404., 1149716., 1255796., 1362644., 838904.,  910136.,  981880.,
      1054136., 1411956., 1518804., 1626420., 1734804., 2435790., 2598366.,
      2762094., 2926974., 2474094., 2638974., 2805006., 2972190., 2512398.,
      2679582., 2847918., 3017406., 1901172., 2014164., 2127924., 2242452.,
      1524276., 1638804., 1754100., 1870164., 2627310., 2801406., 2976654.,
      3153054., 2665614., 2842014., 3019566., 3198270., 2703918., 2882622.,
      3062478., 3243486., 2044212., 2164884., 2286324., 2408532., 1636596.,
      1758804., 1881780., 2005524., 2818830., 3004446., 3191214., 3379134.,
      2857134., 3045054., 3234126., 3424350., 2895438., 3085662., 3277038.,
      3469566., 2187252., 2315604., 2444724., 2574612., 1748916., 1878804.,
      2009460., 2140884., 3010350., 3207486., 3405774., 3605214., 3048654.,
      3248094., 3448686., 3650430., 3086958., 3288702., 3491598., 3695646.,
      2330292., 2466324., 2603124., 2740692., 1739896., 1830584., 1921784.,
      2013496., 2880116., 3017684., 3156020., 3295124., 2914868., 3053972.,
      3193844., 3334484., 2949620., 3090260., 3231668., 3373844., 2156152.,
      2250936., 2346232., 2442040.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,      174.,     446.,     846.,     380.,     1180.,   2236.,
      3548.,    2074.,    4042.,    6394.,    9130.,    5116.,   6940.,
      9020.,    11356.,   4766.,    5934.,    7230.,    8654.,   1020.,
      2844.,    4924.,    7260.,    8824.,    13496.,   18680.,  24376.,
      25460.,   34004.,   43316.,   53396.,   30584.,   37304.,  44536.,
      52280.,   22780.,   26652.,   30780.,   35164.,   12186.,  17226.,
      22650.,   28458.,   43764.,   55380.,   67764.,   80916.,  97806.,
      117534.,  138414.,  160446.,  94836.,   109524.,  124980., 141204.,
      63258.,   71370.,   79866.,   88746.,   41274.,   48618.,  56346.,
      64458.,   111156.,  127380.,  144372.,  162132.,  212718., 239358.,
      267150.,  296094.,  180660.,  199956.,  220020.,  240852., 110778.,
      121194.,  131994.,  143178.,  68412.,   74844.,   81532.,  88476.,
      162040.,  175928.,  190328.,  205240.,  282932.,  305300., 328436.,
      352340.,  220664.,  236600.,  253048.,  270008.,  127036., 135516.,
      144252.,  153244.,  57726.,   61710.,   65822.,   70062.,  131132.,
      139612.,  148348.,  157340.,  221242.,  234730.,  248602., 262858.,
      166588.,  176092.,  185852.,  195868.,  93182.,   98190.,  103326.,
      108590.,  1950.,    5166.,    8510.,    11982.,   16508.,  23452.,
      30652.,   38108.,   44698.,   55882.,   67450.,   79402.,  45820.,
      53788.,   62012.,   70492.,   31262.,   35502.,   39870.,  44366.,
      41724.,   49692.,   57916.,   66396.,   114808.,  131768., 149240.,
      167224.,  221300.,  248276.,  276020.,  304532.,  185720., 204728.,
      224248.,  244280.,  112636.,  122652.,  132924.,  143452., 128538.,
      142794.,  157434.,  172458.,  313332.,  343380.,  374196., 405780.,
      557454.,  604830.,  653358.,  703038.,  438132.,  471252., 505140.,
      539796.,  253338.,  270666.,  288378.,  306474.,  157626., 174186.,
      191130.,  208458.,  380724.,  415380.,  450804.,  486996., 672366.,
      726654.,  782094.,  838686.,  523956.,  561684.,  600180., 639444.,
      300858.,  320490.,  340506.,  360906.,  182844.,  195420., 208252.,
      221340.,  415480.,  441656.,  468344.,  495544.,  699956., 740756.,
      782324.,  824660.,  523256.,  551480.,  580216.,  609464., 290620.,
      305244.,  320124.,  335260.,  133374.,  140430.,  147614., 154926.,
      294716.,  309340.,  324220.,  339356.,  485050.,  507754., 530842.,
      554314.,  354748.,  370396.,  386300.,  402460.,  193406., 201486.,
      209694.,  218030.,  3870.,    10158.,   16574.,   23118.,  32636.,
      45724.,   59068.,   72668.,   87322.,   107722.,  128506., 149674.,
      86524.,   100636.,  115004.,  129628.,  57758.,   65070.,  72510.,
      80078.,   82428.,   96540.,   110908.,  125532.,  220792., 250040.,
      279800.,  310072.,  417140.,  462548.,  508724.,  555668., 340856.,
      372152.,  403960.,  436280.,  202492.,  218652.,  235068., 251740.,
      244890.,  268362.,  292218.,  316458.,  582900.,  631380., 680628.,
      730644.,  1017102., 1092126., 1168302., 1245630., 781428., 832980.,
      885300.,  938388.,  443418.,  469962.,  496890.,  524202., 273978.,
      299754.,  325914.,  352458.,  650292.,  703380.,  757236., 811860.,
      1132014., 1213950., 1297038., 1381278., 867252.,  923412., 980340.,
      1038036., 490938.,  519786.,  549018.,  578634.,  297276., 315996.,
      334972.,  354204.,  668920.,  707384.,  746360.,  785848., 1116980.,
      1176212., 1236212., 1296980., 825848.,  866360.,  907384., 948920.,
      454204.,  474972.,  495996.,  517276.,  209022.,  219150., 229406.,
      239790.,  458300.,  479068.,  500092.,  521372.,  748858., 780778.,
      813082.,  845770.,  542908.,  564700.,  586748.,  609052., 293630.,
      304782.,  316062.,  327470.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35.,   74.,   95.,   116.,  137.,  117.,  129.,  246.,  291.,  336.,
      381.,  306.,  291.,  516.,  561.,  606.,  651.,  504.,  453.,  786.,
      831.,  876.,  921.,  702.,  615.,  1056., 1101., 1146., 1191., 900.,
      665.,  1100., 1139., 1178., 1217., 891.,  467.,  830.,  851.,  872.,
      893.,  693.,  1101., 1866., 1911., 1956., 2001., 1494., 1263., 2136.,
      2181., 2226., 2271., 1692., 1425., 2406., 2451., 2496., 2541., 1890.,
      1587., 2676., 2721., 2766., 2811., 2088., 1529., 2504., 2543., 2582.,
      2621., 1899., 899.,  1586., 1607., 1628., 1649., 1269., 2073., 3486.,
      3531., 3576., 3621., 2682., 2235., 3756., 3801., 3846., 3891., 2880.,
      2397., 4026., 4071., 4116., 4161., 3078., 2559., 4296., 4341., 4386.,
      4431., 3276., 2393., 3908., 3947., 3986., 4025., 2907.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    10.,   16.,   17.,   12.,   9.,    29.,   62.,   83.,
      75.,   48.,   36.,   99.,   192.,  237.,  198.,  120.,  84.,   207.,
      372.,  417.,  330.,  192.,  115.,  263.,  446.,  485.,  365.,  204.,
      91.,   202.,  334.,  358.,  263.,  144.,  17.,   52.,   106.,  112.,
      97.,   60.,   89.,   221.,  398.,  419.,  331.,  192.,  228.,  531.,
      912.,  957.,  726.,  408.,  276.,  639.,  1092., 1137., 858.,  480.,
      291.,  647.,  1070., 1109., 813.,  444.,  203.,  442.,  718.,  742.,
      535.,  288.,  33.,   100.,  202.,  208.,  177.,  108.,  169.,  413.,
      734.,  755.,  587.,  336.,  420.,  963.,  1632., 1677., 1254., 696.,
      468.,  1071., 1812., 1857., 1386., 768.,  467.,  1031., 1694., 1733.,
      1261., 684.,  315.,  682.,  1102., 1126., 807.,  432.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      224.,   496.,   652.,   808.,   964.,   840.,   894.,   1743.,  2085.,
      2427.,  2769.,  2250.,  2118.,  3795.,  4137.,  4479.,  4821.,  3762.,
      3342.,  5847.,  6189.,  6531.,  6873.,  5274.,  4566.,  7899.,  8241.,
      8583.,  8925.,  6786.,  5048.,  8380.,  8680.,  8980.,  9280.,  6816.,
      3392.,  6112.,  6268.,  6424.,  6580.,  5160.,  8238.,  14055., 14397.,
      14739., 15081., 11322., 9462.,  16107., 16449., 16791., 17133., 12834.,
      10686., 18159., 18501., 18843., 19185., 14346., 11910., 20211., 20553.,
      20895., 21237., 15858., 11672., 19180., 19480., 19780., 20080., 14592.,
      6560.,  11728., 11884., 12040., 12196., 9480.,  15582., 26367., 26709.,
      27051., 27393., 20394., 16806., 28419., 28761., 29103., 29445., 21906.,
      18030., 30471., 30813., 31155., 31497., 23418., 19254., 32523., 32865.,
      33207., 33549., 24930., 18296., 29980., 30280., 30580., 30880., 22368.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     22.,   59.,    101.,   114.,   83.,    52.,    184.,  412.,
      568.,   528.,  344.,   237.,   678.,   1347.,  1689.,  1434., 879.,
      597.,   1494., 2715.,  3057.,  2442.,  1431.,  856.,   1968., 3352.,
      3652.,  2760., 1548.,  689.,   1534.,  2543.,  2729.,  2010., 1103.,
      101.,   342.,  731.,   773.,   690.,   435.,   628.,   1592., 2908.,
      3064.,  2448., 1432.,  1677.,  3942.,  6819.,  7161.,  5466., 3087.,
      2037.,  4758., 8187.,  8529.,  6474.,  3639.,  2200.,  4912., 8152.,
      8452.,  6216., 3404.,  1553.,  3390.,  5519.,  5705.,  4122., 2223.,
      197.,   662.,  1403.,  1445.,  1266.,  787.,   1204.,  3000., 5404.,
      5560.,  4368., 2520.,  3117.,  7206.,  12291., 12633., 9498., 5295.,
      3477.,  8022., 13659., 14001., 10506., 5847.,  3544.,  7856., 12952.,
      13252., 9672., 5260.,  2417.,  5246.,  8495.,  8681.,  6234., 3343.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1576.,   3596.,   4796.,   5996.,   7196.,   6344.,   6612.,   13062.,
      15726.,  18390.,  21054.,  17220.,  16116.,  29046.,  31710.,  34374.,
      37038.,  29028.,  25620.,  45030.,  47694.,  50358.,  53022.,  40836.,
      35124.,  61014.,  63678.,  66342.,  69006.,  52644.,  39304.,  65372.,
      67724.,  70076.,  72428.,  53288.,  25768.,  46796.,  47996.,  49196.,
      50396.,  39752.,  63636.,  108966., 111630., 114294., 116958., 88068.,
      73140.,  124950., 127614., 130278., 132942., 99876.,  82644.,  140934.,
      143598., 146262., 148926., 111684., 92148.,  156918., 159582., 162246.,
      164910., 123492., 91144.,  150044., 152396., 154748., 157100., 114344.,
      49960.,  89996.,  91196.,  92396.,  93596.,  73160.,  120660., 204870.,
      207534., 210198., 212862., 158916., 130164., 220854., 223518., 226182.,
      228846., 170724., 139668., 236838., 239502., 242166., 244830., 182532.,
      149172., 252822., 255486., 258150., 260814., 194340., 142984., 234716.,
      237068., 239420., 241772., 175400.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,    140.,   394.,    706.,    828.,    614.,    340.,   1288.,
      2972.,  4172.,  3944.,   2596.,   1698.,   4980.,   10038., 12702.,
      10884., 6714.,  4482.,   11316.,  20694.,  23358.,  18756., 11034.,
      6596.,  15208., 25964.,  28316.,  21448.,  12052.,  5358.,  11948.,
      19834., 21298., 15708.,  8630.,   670.,    2444.,   5386.,  5698.,
      5180.,  3302.,  4692.,   12040.,  22172.,  23372.,  18792., 11044.,
      12834., 30324., 52662.,  55326.,  42372.,  23994.,  15618., 36660.,
      63318., 65982., 50244.,  28314.,  17092.,  38248.,  63596., 65948.,
      48584., 26644., 12142.,  26540.,  43258.,  44722.,  32348., 17462.,
      1310.,  4748.,  10378.,  10690.,  9532.,   5990.,   9044.,  22792.,
      41372., 42572., 33640.,  19492.,  23970.,  55668.,  95286., 97950.,
      73860., 41274., 26754.,  62004.,  105942., 108606., 81732., 45594.,
      27588., 61288., 101228., 103580., 75720.,  41236.,  18926., 41132.,
      66682., 68146., 48988.,  26294.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84.,    140.,   200.,   296.,   272.,   380.,   344.,   464.,   416.,
      548.,   372.,   468.,   378.,   516.,   759.,   984.,   921.,   1164.,
      1083.,  1344.,  1245.,  1524.,  1026.,  1224.,  954.,   1164.,  1731.,
      2064.,  1893.,  2244.,  2055.,  2424.,  2217.,  2604.,  1746.,  2016.,
      1530.,  1812.,  2703.,  3144.,  2865.,  3324.,  3027.,  3504.,  3189.,
      3684.,  2466.,  2808.,  2106.,  2460.,  3675.,  4224.,  3837.,  4404.,
      3999.,  4584.,  4161.,  4764.,  3186.,  3600.,  2388.,  2660.,  3980.,
      4400.,  4124.,  4556.,  4268.,  4712.,  4412.,  4868.,  3252.,  3564.,
      1524.,  1868.,  2792.,  3320.,  2864.,  3404.,  2936.,  3488.,  3008.,
      3572.,  2388.,  2772.,  3834.,  4404.,  6591.,  7464.,  6753.,  7644.,
      6915.,  7824.,  7077.,  8004.,  5346.,  5976.,  4410.,  5052.,  7563.,
      8544.,  7725.,  8724.,  7887.,  8904.,  8049.,  9084.,  6066.,  6768.,
      4986.,  5700.,  8535.,  9624.,  8697.,  9804.,  8859.,  9984.,  9021.,
      10164., 6786.,  7560.,  5562.,  6348.,  9507.,  10704., 9669.,  10884.,
      9831.,  11064., 9993.,  11244., 7506.,  8352.,  5556.,  6116.,  9164.,
      10016., 9308.,  10172., 9452.,  10328., 9596.,  10484., 6996.,  7596.,
      2964.,  3596.,  5384.,  6344.,  5456.,  6428.,  5528.,  6512.,  5600.,
      6596.,  4404.,  5076.,  7290.,  8292.,  12423., 13944., 12585., 14124.,
      12747., 14304., 12909., 14484., 9666.,  10728., 7866.,  8940.,  13395.,
      15024., 13557., 15204., 13719., 15384., 13881., 15564., 10386., 11520.,
      8442.,  9588.,  14367., 16104., 14529., 16284., 14691., 16464., 14853.,
      16644., 11106., 12312., 9018.,  10236., 15339., 17184., 15501., 17364.,
      15663., 17544., 15825., 17724., 11826., 13104., 8724.,  9572.,  14348.,
      15632., 14492., 15788., 14636., 15944., 14780., 16100., 10740., 11628.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,    4.,    6.,    16.,   19.,   40.,   37.,   64.,   46.,   68.,
      35.,   48.,   16.,   36.,   68.,   116.,  164.,  248.,  236.,  332.,
      228.,  300.,  152.,  192.,  93.,   144.,  282.,  396.,  579.,  768.,
      741.,  948.,  642.,  792.,  399.,  480.,  261.,  336.,  666.,  828.,
      1227., 1488., 1389., 1668., 1122., 1320., 663.,  768.,  396.,  460.,
      916.,  1052., 1568., 1784., 1712., 1940., 1300., 1460., 732.,  816.,
      325.,  364.,  726.,  808.,  1207., 1336., 1297., 1432., 958.,  1052.,
      527.,  576.,  33.,   68.,   134.,  208.,  307.,  424.,  325.,  448.,
      302.,  388.,  195.,  240.,  272.,  356.,  708.,  884.,  1316., 1592.,
      1388., 1676., 1124., 1324., 664.,  768.,  765.,  912.,  1818., 2124.,
      3171., 3648., 3333., 3828., 2562., 2904., 1455., 1632., 933.,  1104.,
      2202., 2556., 3819., 4368., 3981., 4548., 3042., 3432., 1719., 1920.,
      1036., 1164., 2324., 2588., 3872., 4280., 4016., 4436., 2964., 3252.,
      1628., 1776., 741.,  812.,  1622., 1768., 2647., 2872., 2737., 2968.,
      1982., 2140., 1071., 1152., 65.,   132.,  262.,  400.,  595.,  808.,
      613.,  832.,  558.,  708.,  355.,  432.,  528.,  676.,  1348., 1652.,
      2468., 2936., 2540., 3020., 2020., 2348., 1176., 1344., 1437., 1680.,
      3354., 3852., 5763., 6528., 5925., 6708., 4482., 5016., 2511., 2784.,
      1605., 1872., 3738., 4284., 6411., 7248., 6573., 7428., 4962., 5544.,
      2775., 3072., 1676., 1868., 3732., 4124., 6176., 6776., 6320., 6932.,
      4628., 5044., 2524., 2736., 1157., 1260., 2518., 2728., 4087., 4408.,
      4177., 4504., 3006., 3228., 1615., 1728.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      572.,    1004.,   1426.,   2170.,   1978.,   2818.,   2530.,   3466.,
      3082.,   4114.,   2796.,   3548.,   2766.,   3846.,   5649.,   7413.,
      6909.,   8817.,   8169.,   10221.,  9429.,   11625.,  7830.,   9390.,
      7230.,   8886.,   13209.,  15837.,  14469.,  17241.,  15729.,  18645.,
      16989.,  20049.,  13446.,  15582.,  11694.,  13926.,  20769.,  24261.,
      22029.,  25665.,  23289.,  27069.,  24549.,  28473.,  19062.,  21774.,
      16158.,  18966.,  28329.,  32685.,  29589.,  34089.,  30849.,  35493.,
      32109.,  36897.,  24678.,  27966.,  18572.,  20732.,  31018.,  34354.,
      32146.,  35578.,  33274.,  36802.,  34402.,  38026.,  25404.,  27884.,
      11516.,  14252.,  21298.,  25498.,  21850.,  26146.,  22402.,  26794.,
      22954.,  27442.,  18348.,  21404.,  29550.,  34086.,  51009.,  57957.,
      52269.,  59361.,  53529.,  60765.,  54789.,  62169.,  41526.,  46542.,
      34014.,  39126.,  58569.,  66381.,  59829.,  67785.,  61089.,  69189.,
      62349.,  70593.,  47142.,  52734.,  38478.,  44166.,  66129.,  74805.,
      67389.,  76209.,  68649.,  77613.,  69909.,  79017.,  52758.,  58926.,
      42942.,  49206.,  73689.,  83229.,  74949.,  84633.,  76209.,  86037.,
      77469.,  87441.,  58374.,  65118.,  43340.,  47804.,  71626.,  78418.,
      72754.,  79642.,  73882.,  80866.,  75010.,  82090.,  54780.,  59564.,
      22460.,  27500.,  41170.,  48826.,  41722.,  49474.,  42274.,  50122.,
      42826.,  50770.,  33900.,  39260.,  56334.,  64326.,  96369.,  108501.,
      97629.,  109905., 98889.,  111309., 100149., 112713., 75222.,  83694.,
      60798.,  69366.,  103929., 116925., 105189., 118329., 106449., 119733.,
      107709., 121137., 80838.,  89886.,  65262.,  74406.,  111489., 125349.,
      112749., 126753., 114009., 128157., 115269., 129561., 86454.,  96078.,
      69726.,  79446.,  119049., 133773., 120309., 135177., 121569., 136581.,
      122829., 137985., 92070.,  102270., 68108.,  74876.,  112234., 122482.,
      113362., 123706., 114490., 124930., 115618., 126154., 84156.,  91244.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,     25.,    34.,    106.,   119.,   275.,   251.,   455.,   330.,
      498.,   257.,   357.,   94.,    246.,   460.,   828.,   1162.,  1810.,
      1714.,  2458.,  1692.,  2252.,  1142.,  1454.,  651.,   1047.,  2046.,
      2934.,  4281.,  5757.,  5541.,  7161.,  4854.,  6030.,  3039.,  3675.,
      1947.,  2535.,  5022.,  6294.,  9321.,  11373., 10581., 12777., 8598.,
      10158., 5103.,  5931.,  3046.,  3550.,  7068.,  8140.,  12130., 13834.,
      13258., 15058., 10092., 11356., 5694.,  6358.,  2525.,  2833.,  5650.,
      6298.,  9407.,  10427., 10115., 11183., 7482.,  8226.,  4121.,  4509.,
      197.,   473.,   930.,   1514.,  2231.,  3155.,  2363.,  3335.,  2250.,
      2930.,  1473.,  1829.,  2014.,  2678.,  5324.,  6716.,  9994.,  12178.,
      10546., 12826., 8604.,  10188., 5110.,  5934.,  5835.,  6999.,  13950.,
      16374., 24441., 28221., 25701., 29625., 19830., 22542., 11295., 12699.,
      7131.,  8487.,  16926., 19734., 29481., 33837., 30741., 35241., 23574.,
      26670., 13359., 14955., 8038.,  9054.,  18076., 20172., 30178., 33418.,
      31306., 34642., 23148., 25436., 12734., 13910., 5789.,  6353.,  12690.,
      13850., 20735., 22523., 21443., 23279., 15546., 16802., 8409.,  9053.,
      389.,   921.,   1826.,  2922.,  4343.,  6035.,  4475.,  6215.,  4170.,
      5362.,  2689.,  3301.,  3934.,  5110.,  10188., 12604., 18826., 22546.,
      19378., 23194., 15516., 18124., 9078.,  10414., 11019., 12951., 25854.,
      29814., 44601., 50685., 45861., 52089., 34806., 39054., 19551., 21723.,
      12315., 14439., 28830., 33174., 49641., 56301., 50901., 57705., 38550.,
      43182., 21615., 23979., 13030., 14558., 29084., 32204., 48226., 53002.,
      49354., 54226., 36204., 39516., 19774., 21462., 9053.,  9873.,  19730.,
      21402., 32063., 34619., 32771., 35375., 23610., 25378., 12697., 13597.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4184.,    7576.,    10724.,  16580.,   15044.,  21668.,   19364.,
      26756.,   23684.,   31844.,  21656.,   27608.,  21108.,   29652.,
      43518.,   57486.,   53454.,  68574.,   63390.,  79662.,   73326.,
      90750.,   61140.,   73524.,  56244.,   69396.,  103134.,  124014.,
      113070.,  135102.,  123006., 146190.,  132942., 157278.,  105492.,
      122484.,  91380.,   109140., 162750.,  190542., 172686.,  201630.,
      182622.,  212718.,  192558., 223806.,  149844., 171444.,  126516.,
      148884.,  222366.,  257070., 232302.,  268158., 242238.,  279246.,
      252174.,  290334.,  194196., 220404.,  146456., 163672.,  244868.,
      271460.,  253796.,  281156., 262724.,  290852., 271652.,  300548.,
      200792.,  220568.,  89432.,  111256.,  166244., 199748.,  170564.,
      204836.,  174884.,  209924., 179204.,  215012., 143768.,  168152.,
      231924.,  268116.,  401214., 456654.,  411150., 467742.,  421086.,
      478830.,  431022.,  489918., 327252.,  367284., 267060.,  307860.,
      460830.,  523182.,  470766., 534270.,  480702., 545358.,  490638.,
      556446.,  371604.,  416244., 302196.,  347604., 520446.,  589710.,
      530382.,  600798.,  540318., 611886.,  550254., 622974.,  415956.,
      465204.,  337332.,  387348., 580062.,  656238., 589998.,  667326.,
      599934.,  678414.,  609870., 689502.,  460308., 514164.,  342296.,
      377944.,  566276.,  620516., 575204.,  630212., 584132.,  639908.,
      593060.,  649604.,  433496., 471704.,  174680., 214936.,  321764.,
      382916.,  326084.,  388004., 330404.,  393092., 334724.,  398180.,
      265880.,  308696.,  442740., 506580.,  758910., 855822.,  768846.,
      866910.,  778782.,  877998., 788718.,  889086., 593364.,  661044.,
      477876.,  546324.,  818526., 922350.,  828462., 933438.,  838398.,
      944526.,  848334.,  955614., 637716.,  710004., 513012.,  586068.,
      878142.,  988878.,  888078., 999966.,  898014., 1011054., 907950.,
      1022142., 682068.,  758964., 548148.,  625812., 937758.,  1055406.,
      947694.,  1066494., 957630., 1077582., 967566., 1088670., 726420.,
      807924.,  538136.,  592216., 887684.,  969572., 896612.,  979268.,
      905540.,  988964.,  914468., 998660.,  666200., 722840.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,     174.,    220.,    764.,    826.,    2026.,   1834.,   3418.,
      2492.,   3804.,   1966.,   2750.,   620.,    1804.,   3352.,   6232.,
      8708.,   13796.,  13028.,  18884.,  13016.,  17432.,  8844.,   11308.,
      4842.,   7962.,   15540.,  22548.,  32862.,  44526.,  42798.,  55614.,
      37716.,  47028.,  23706.,  28746.,  15018.,  19674.,  38964.,  49044.,
      72606.,  88878.,  82542.,  99966.,  67284.,  79668.,  40026.,  46602.,
      23884.,  27884.,  55512.,  64024.,  95396.,  108932., 104324., 118628.,
      79512.,  89560.,  44908.,  50188.,  19902.,  22350.,  44572.,  49724.,
      74266.,  82378.,  79882.,  88378.,  59132.,  65052.,  32590.,  35678.,
      1310.,   3502.,   6876.,   11516.,  16954.,  24298.,  17962.,  25690.,
      17340.,  22748.,  11438.,  14270.,  15468.,  20748.,  41240.,  52312.,
      77828.,  95204.,  82148.,  100292., 67288.,  79896.,  40076.,  46636.,
      45546.,  54810.,  109236., 128532., 191838., 221934., 201774., 233022.,
      155988., 177588., 88986.,  100170., 55722.,  66522.,  132660., 155028.,
      231582., 266286., 241518., 277374., 185556., 210228., 105306., 118026.,
      63308.,  71404.,  142552., 159256., 238244., 264068., 247172., 273764.,
      182936., 201176., 100716., 110092., 45758.,  50254.,  100380., 109628.,
      164122., 178378., 169738., 184378., 123132., 133148., 66638.,  71774.,
      2590.,   6830.,   13532.,  22268.,  33082.,  46570.,  34090.,  47962.,
      32188.,  41692.,  20910.,  25790.,  30316.,  39692.,  79128.,  98392.,
      146948., 176612., 151268., 181700., 121560., 142360., 71308.,  81964.,
      86250.,  101658., 202932., 234516., 350814., 399342., 360750., 410430.,
      274260., 308148., 154266., 171594., 96426.,  113370., 226356., 261012.,
      390558., 443694., 400494., 454782., 303828., 340788., 170586., 189450.,
      102732., 114924., 229592., 254488., 381092., 419204., 390020., 428900.,
      286360., 312792., 156524., 169996., 71614.,  78158.,  156188., 169532.,
      253978., 274378., 259594., 280378., 187132., 201244., 100686., 107870.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      236.,   336.,   444.,   560.,   626.,   800.,   986.,   1184.,  890.,
      1088.,  1298.,  1520.,  1154.,  1376.,  1610.,  1856.,  1418.,  1664.,
      1922.,  2192.,  1308.,  1488.,  1676.,  1872.,  1254.,  1512.,  1782.,
      2064.,  2613.,  3036.,  3477.,  3936.,  3225.,  3684.,  4161.,  4656.,
      3837.,  4332.,  4845.,  5376.,  4449.,  4980.,  5529.,  6096.,  3726.,
      4104.,  4494.,  4896.,  3414.,  3816.,  4230.,  4656.,  6285.,  6924.,
      7581.,  8256.,  6897.,  7572.,  8265.,  8976.,  7509.,  8220.,  8949.,
      9696.,  8121.,  8868.,  9633.,  10416., 6462.,  6984.,  7518.,  8064.,
      5574.,  6120.,  6678.,  7248.,  9957.,  10812., 11685., 12576., 10569.,
      11460., 12369., 13296., 11181., 12108., 13053., 14016., 11793., 12756.,
      13737., 14736., 9198.,  9864.,  10542., 11232., 7734.,  8424.,  9126.,
      9840.,  13629., 14700., 15789., 16896., 14241., 15348., 16473., 17616.,
      14853., 15996., 17157., 18336., 15465., 16644., 17841., 19056., 11934.,
      12744., 13566., 14400., 9020.,  9552.,  10092., 10640., 15098., 15920.,
      16754., 17600., 15650., 16496., 17354., 18224., 16202., 17072., 17954.,
      18848., 16754., 17648., 18554., 19472., 12396., 13008., 13628., 14256.,
      5420.,  6096.,  6780.,  7472.,  10130., 11168., 12218., 13280., 10394.,
      11456., 12530., 13616., 10658., 11744., 12842., 13952., 10922., 12032.,
      13154., 14288., 8796.,  9552.,  10316., 11088., 14214., 15336., 16470.,
      17616., 24645., 26364., 28101., 29856., 25257., 27012., 28785., 30576.,
      25869., 27660., 29469., 31296., 26481., 28308., 30153., 32016., 20142.,
      21384., 22638., 23904., 16374., 17640., 18918., 20208., 28317., 30252.,
      32205., 34176., 28929., 30900., 32889., 34896., 29541., 31548., 33573.,
      35616., 30153., 32196., 34257., 36336., 22878., 24264., 25662., 27072.,
      18534., 19944., 21366., 22800., 31989., 34140., 36309., 38496., 32601.,
      34788., 36993., 39216., 33213., 35436., 37677., 39936., 33825., 36084.,
      38361., 40656., 25614., 27144., 28686., 30240., 20694., 22248., 23814.,
      25392., 35661., 38028., 40413., 42816., 36273., 38676., 41097., 43536.,
      36885., 39324., 41781., 44256., 37497., 39972., 42465., 44976., 28350.,
      30024., 31710., 33408., 21116., 22224., 23340., 24464., 34970., 36656.,
      38354., 40064., 35522., 37232., 38954., 40688., 36074., 37808., 39554.,
      41312., 36626., 38384., 40154., 41936., 26796., 27984., 29180., 30384.,
      10604., 11856., 13116., 14384., 19634., 21536., 23450., 25376., 19898.,
      21824., 23762., 25712., 20162., 22112., 24074., 26048., 20426., 22400.,
      24386., 26384., 16284., 17616., 18956., 20304., 27174., 29160., 31158.,
      33168., 46677., 49692., 52725., 55776., 47289., 50340., 53409., 56496.,
      47901., 50988., 54093., 57216., 48513., 51636., 54777., 57936., 36558.,
      38664., 40782., 42912., 29334., 31464., 33606., 35760., 50349., 53580.,
      56829., 60096., 50961., 54228., 57513., 60816., 51573., 54876., 58197.,
      61536., 52185., 55524., 58881., 62256., 39294., 41544., 43806., 46080.,
      31494., 33768., 36054., 38352., 54021., 57468., 60933., 64416., 54633.,
      58116., 61617., 65136., 55245., 58764., 62301., 65856., 55857., 59412.,
      62985., 66576., 42030., 44424., 46830., 49248., 33654., 36072., 38502.,
      40944., 57693., 61356., 65037., 68736., 58305., 62004., 65721., 69456.,
      58917., 62652., 66405., 70176., 59529., 63300., 67089., 70896., 44766.,
      47304., 49854., 52416., 33212., 34896., 36588., 38288., 54842., 57392.,
      59954., 62528., 55394., 57968., 60554., 63152., 55946., 58544., 61154.,
      63776., 56498., 59120., 61754., 64400., 41196., 42960., 44732., 46512.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1.,     4.,     9.,     16.,    10.,    24.,    42.,    64.,    43.,
      76.,    115.,   160.,   103.,   148.,   199.,   256.,   146.,   184.,
      226.,   272.,   117.,   140.,   165.,   192.,   30.,    64.,    102.,
      144.,   188.,   272.,   364.,   464.,   506.,   656.,   818.,   992.,
      770.,   944.,   1130.,  1328.,  780.,   912.,   1052.,  1200.,  534.,
      608.,   686.,   768.,   279.,   372.,   471.,   576.,   918.,   1128.,
      1350.,  1584.,  1965.,  2316.,  2685.,  3072.,  2577.,  2964.,  3369.,
      3792.,  2286.,  2568.,  2862.,  3168.,  1443.,  1596.,  1755.,  1920.,
      903.,   1044.,  1191.,  1344.,  2358.,  2664.,  2982.,  3312.,  4413.,
      4908.,  5421.,  5952.,  5025.,  5556.,  6105.,  6672.,  4110.,  4488.,
      4878.,  5280.,  2451.,  2652.,  2859.,  3072.,  1462.,  1584.,  1710.,
      1840.,  3404.,  3664.,  3932.,  4208.,  5858.,  6272.,  6698.,  7136.,
      6410.,  6848.,  7298.,  7760.,  4892.,  5200.,  5516.,  5840.,  2766.,
      2928.,  3094.,  3264.,  1225.,  1300.,  1377.,  1456.,  2746.,  2904.,
      3066.,  3232.,  4579.,  4828.,  5083.,  5344.,  4927.,  5188.,  5455.,
      5728.,  3650.,  3832.,  4018.,  4208.,  2013.,  2108.,  2205.,  2304.,
      65.,    132.,   201.,   272.,   394.,   536.,   682.,   832.,   1003.,
      1228.,  1459.,  1696.,  1063.,  1300.,  1543.,  1792.,  1042.,  1208.,
      1378.,  1552.,  693.,   780.,   869.,   960.,   926.,   1088.,  1254.,
      1424.,  2492.,  2832.,  3180.,  3536.,  4730.,  5264.,  5810.,  6368.,
      4994.,  5552.,  6122.,  6704.,  4108.,  4496.,  4892.,  5296.,  2454.,
      2656.,  2862.,  3072.,  2775.,  3060.,  3351.,  3648.,  6678.,  7272.,
      7878.,  8496.,  11757., 12684., 13629., 14592., 12369., 13332., 14313.,
      15312., 9582.,  10248., 10926., 11616., 5475.,  5820.,  6171.,  6528.,
      3399.,  3732.,  4071.,  4416.,  8118.,  8808.,  9510.,  10224., 14205.,
      15276., 16365., 17472., 14817., 15924., 17049., 18192., 11406., 12168.,
      12942., 13728., 6483.,  6876.,  7275.,  7680.,  3894.,  4144.,  4398.,
      4656.,  8780.,  9296.,  9820.,  10352., 14690., 15488., 16298., 17120.,
      15242., 16064., 16898., 17744., 11292., 11856., 12428., 13008., 6222.,
      6512.,  6806.,  7104.,  2825.,  2964.,  3105.,  3248.,  6202.,  6488.,
      6778.,  7072.,  10147., 10588., 11035., 11488., 10495., 10948., 11407.,
      11872., 7618.,  7928.,  8242.,  8560.,  4125.,  4284.,  4445.,  4608.,
      129.,   260.,   393.,   528.,   778.,   1048.,  1322.,  1600.,  1963.,
      2380.,  2803.,  3232.,  2023.,  2452.,  2887.,  3328.,  1938.,  2232.,
      2530.,  2832.,  1269.,  1420.,  1573.,  1728.,  1822.,  2112.,  2406.,
      2704.,  4796.,  5392.,  5996.,  6608.,  8954.,  9872.,  10802., 11744.,
      9218.,  10160., 11114., 12080., 7436.,  8080.,  8732.,  9392.,  4374.,
      4704.,  5038.,  5376.,  5271.,  5748.,  6231.,  6720.,  12438., 13416.,
      14406., 15408., 21549., 23052., 24573., 26112., 22161., 23700., 25257.,
      26832., 16878., 17928., 18990., 20064., 9507.,  10044., 10587., 11136.,
      5895.,  6420.,  6951.,  7488.,  13878., 14952., 16038., 17136., 23997.,
      25644., 27309., 28992., 24609., 26292., 27993., 29712., 18702., 19848.,
      21006., 22176., 10515., 11100., 11691., 12288., 6326.,  6704.,  7086.,
      7472.,  14156., 14928., 15708., 16496., 23522., 24704., 25898., 27104.,
      24074., 25280., 26498., 27728., 17692., 18512., 19340., 20176., 9678.,
      10096., 10518., 10944., 4425.,  4628.,  4833.,  5040.,  9658.,  10072.,
      10490., 10912., 15715., 16348., 16987., 17632., 16063., 16708., 17359.,
      18016., 11586., 12024., 12466., 12912., 6237.,  6460.,  6685.,  6912.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1700.,   2484.,   3332.,   4244.,   4678.,   6046.,   7510.,   9070.,
      6742.,   8302.,   9958.,   11710.,  8806.,   10558.,  12406.,  14350.,
      10870.,  12814.,  14854.,  16990.,  10116.,  11540.,  13028.,  14580.,
      9534.,   11574.,  13710.,  15942.,  20085.,  23433.,  26925.,  30561.,
      24909.,  28545.,  32325.,  36249.,  29733.,  33657.,  37725.,  41937.,
      34557.,  38769.,  43125.,  47625.,  29070.,  32070.,  35166.,  38358.,
      26526.,  29718.,  33006.,  36390.,  49029.,  54105.,  59325.,  64689.,
      53853.,  59217.,  64725.,  70377.,  58677.,  64329.,  70125.,  76065.,
      63501.,  69441.,  75525.,  81753.,  50670.,  54822.,  59070.,  63414.,
      43518.,  47862.,  52302.,  56838.,  77973.,  84777.,  91725.,  98817.,
      82797.,  89889.,  97125.,  104505., 87621.,  95001.,  102525., 110193.,
      92445.,  100113., 107925., 115881., 72270.,  77574.,  82974.,  88470.,
      60510.,  66006.,  71598.,  77286.,  106917., 115449., 124125., 132945.,
      111741., 120561., 129525., 138633., 116565., 125673., 134925., 144321.,
      121389., 130785., 140325., 150009., 93870.,  100326., 106878., 113526.,
      71108.,  75348.,  79652.,  84020.,  119158., 125710., 132358., 139102.,
      123526., 130270., 137110., 144046., 127894., 134830., 141862., 148990.,
      132262., 139390., 146614., 153934., 97956.,  102836., 107780., 112788.,
      42020.,  47412.,  52868.,  58388.,  78982.,  87262.,  95638.,  104110.,
      81046.,  89518.,  98086.,  106750., 83110.,  91774.,  100534., 109390.,
      85174.,  94030.,  102982., 112030., 68868.,  74900.,  80996.,  87156.,
      111486., 120438., 129486., 138630., 193749., 207465., 221325., 235329.,
      198573., 212577., 226725., 241017., 203397., 217689., 232125., 246705.,
      208221., 222801., 237525., 252393., 158670., 168582., 178590., 188694.,
      128478., 138582., 148782., 159078., 222693., 238137., 253725., 269457.,
      227517., 243249., 259125., 275145., 232341., 248361., 264525., 280833.,
      237165., 253473., 269925., 286521., 180270., 191334., 202494., 213750.,
      145470., 156726., 168078., 179526., 251637., 268809., 286125., 303585.,
      256461., 273921., 291525., 309273., 261285., 279033., 296925., 314961.,
      266109., 284145., 302325., 320649., 201870., 214086., 226398., 238806.,
      162462., 174870., 187374., 199974., 280581., 299481., 318525., 337713.,
      285405., 304593., 323925., 343401., 290229., 309705., 329325., 349089.,
      295053., 314817., 334725., 354777., 223470., 236838., 250302., 263862.,
      166724., 175572., 184484., 193460., 276406., 289870., 303430., 317086.,
      280774., 294430., 308182., 322030., 285142., 298990., 312934., 326974.,
      289510., 303550., 317686., 331918., 212004., 221492., 231044., 240660.,
      82340.,  92340.,  102404., 112532., 153286., 168478., 183766., 199150.,
      155350., 170734., 186214., 201790., 157414., 172990., 188662., 204430.,
      159478., 175246., 191110., 207070., 127620., 138260., 148964., 159732.,
      213438., 229302., 245262., 261318., 367413., 391497., 415725., 440097.,
      372237., 396609., 421125., 445785., 377061., 401721., 426525., 451473.,
      381885., 406833., 431925., 457161., 288270., 305094., 322014., 339030.,
      230430., 247446., 264558., 281766., 396357., 422169., 448125., 474225.,
      401181., 427281., 453525., 479913., 406005., 432393., 458925., 485601.,
      410829., 437505., 464325., 491289., 309870., 327846., 345918., 364086.,
      247422., 265590., 283854., 302214., 425301., 452841., 480525., 508353.,
      430125., 457953., 485925., 514041., 434949., 463065., 491325., 519729.,
      439773., 468177., 496725., 525417., 331470., 350598., 369822., 389142.,
      264414., 283734., 303150., 322662., 454245., 483513., 512925., 542481.,
      459069., 488625., 518325., 548169., 463893., 493737., 523725., 553857.,
      468717., 498849., 529125., 559545., 353070., 373350., 393726., 414198.,
      262340., 275796., 289316., 302900., 433654., 454030., 474502., 495070.,
      438022., 458590., 479254., 500014., 442390., 463150., 484006., 504958.,
      446758., 467710., 488758., 509902., 326052., 340148., 354308., 368532.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5.,      25.,     61.,     113.,    58.,     162.,    298.,    466.,
      287.,    539.,    839.,    1187.,   743.,    1091.,   1487.,   1931.,
      1098.,   1394.,   1722.,   2082.,   893.,    1073.,   1269.,   1481.,
      178.,    442.,    738.,    1066.,   1348.,   2004.,   2724.,   3508.,
      3766.,   4942.,   6214.,   7582.,   5830.,   7198.,   8662.,   10222.,
      5988.,   7028.,   8132.,   9300.,   4130.,   4714.,   5330.,   5978.,
      2055.,   2787.,   3567.,   4395.,   6942.,   8598.,   10350.,  12198.,
      15045.,  17817.,  20733.,  23793.,  19869.,  22929.,  26133.,  29481.,
      17742.,  19974.,  22302.,  24726.,  11247.,  12459.,  13719.,  15027.,
      6951.,   8067.,   9231.,   10443.,  18270.,  20694.,  23214.,  25830.,
      34341.,  38265.,  42333.,  46545.,  39165.,  43377.,  47733.,  52233.,
      32142.,  35142.,  38238.,  41430.,  19215.,  20811.,  22455.,  24147.,
      11458.,  12426.,  13426.,  14458.,  26724.,  28788.,  30916.,  33108.,
      46054.,  49342.,  52726.,  56206.,  50422.,  53902.,  57478.,  61150.,
      38532.,  40980.,  43492.,  46068.,  21810.,  23098.,  24418.,  25770.,
      9653.,   10249.,  10861.,  11489.,  21658.,  22914.,  24202.,  25522.,
      36143.,  38123.,  40151.,  42227.,  38903.,  40979.,  43103.,  45275.,
      28842.,  30290.,  31770.,  33282.,  15917.,  16673.,  17445.,  18233.,
      389.,    921.,    1469.,   2033.,   2874.,   4002.,   5162.,   6354.,
      7583.,   9371.,   11207.,  13091.,  8039.,   9923.,   11855.,  13835.,
      8010.,   9330.,   10682.,  12066.,  5373.,   6065.,   6773.,   7497.,
      7090.,   8378.,   9698.,   11050.,  19268.,  21972.,  24740.,  27572.,
      36790.,  41038.,  45382.,  49822.,  38854.,  43294.,  47830.,  52462.,
      32100.,  35188.,  38340.,  41556.,  19234.,  20842.,  22482.,  24154.,
      21639.,  23907.,  26223.,  28587.,  52254.,  56982.,  61806.,  66726.,
      92229.,  99609.,  107133., 114801., 97053.,  104721., 112533., 120489.,
      75342.,  80646.,  86046.,  91542.,  43119.,  45867.,  48663.,  51507.,
      26535.,  29187.,  31887.,  34635.,  63582.,  69078.,  74670.,  80358.,
      111525., 120057., 128733., 137553., 116349., 125169., 134133., 143241.,
      89742.,  95814.,  101982., 108246., 51087.,  54219.,  57399.,  60627.,
      30658.,  32650.,  34674.,  36730.,  69220.,  73332.,  77508.,  81748.,
      115942., 122302., 128758., 135310., 120310., 126862., 133510., 140254.,
      89220.,  93716.,  98276.,  102900., 49202.,  51514.,  53858.,  56234.,
      22325.,  23433.,  24557.,  25697.,  49050.,  51330.,  53642.,  55986.,
      80303.,  83819.,  87383.,  90995.,  83063.,  86675.,  90335.,  94043.,
      60330.,  62802.,  65306.,  67842.,  32685.,  33953.,  35237.,  36537.,
      773.,    1817.,   2877.,   3953.,   5690.,   7842.,   10026.,  12242.,
      14879.,  18203.,  21575.,  24995.,  15335.,  18755.,  22223.,  25739.,
      14922.,  17266.,  19642.,  22050.,  9853.,   11057.,  12277.,  13513.,
      14002.,  16314.,  18658.,  21034.,  37188.,  41940.,  46756.,  51636.,
      69814.,  77134.,  84550.,  92062.,  71878.,  79390.,  86998.,  94702.,
      58212.,  63348.,  68548.,  73812.,  34338.,  36970.,  39634.,  42330.,
      41223.,  45027.,  48879.,  52779.,  97566.,  105366., 113262., 121254.,
      169413., 181401., 193533., 205809., 174237., 186513., 198933., 211497.,
      132942., 141318., 149790., 158358., 74991.,  79275.,  83607.,  87987.,
      46119.,  50307.,  54543.,  58827.,  108894., 117462., 126126., 134886.,
      188709., 201849., 215133., 228561., 193533., 206961., 220533., 234249.,
      147342., 156486., 165726., 175062., 82959.,  87627.,  92343.,  97107.,
      49858.,  52874.,  55922.,  59002.,  111716., 117876., 124100., 130388.,
      185830., 195262., 204790., 214414., 190198., 199822., 209542., 219358.,
      139908., 146452., 153060., 159732., 76594.,  79930.,  83298.,  86698.,
      34997.,  36617.,  38253.,  39905.,  76442.,  79746.,  83082.,  86450.,
      124463., 129515., 134615., 139763., 127223., 132371., 137567., 142811.,
      91818.,  95314.,  98842.,  102402., 49453.,  51233.,  53029.,  54841.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12856.,   19064.,   25784.,   33016.,   36116.,   46964.,   58580.,
      70964.,   52436.,   64820.,   77972.,   91892.,   68756.,   82676.,
      97364.,   112820.,  85076.,   100532.,  116756.,  133748.,  79544.,
      90872.,   102712.,  115064.,  74292.,   90516.,   107508.,  125268.,
      157422.,  184062.,  211854.,  240798.,  195726.,  224670.,  254766.,
      286014.,  234030.,  265278.,  297678.,  331230.,  272334.,  305886.,
      340590.,  376446.,  229620.,  253524.,  278196.,  303636.,  209076.,
      234516.,  260724.,  287700.,  387246.,  427710.,  469326.,  512094.,
      425550.,  468318.,  512238.,  557310.,  463854.,  508926.,  555150.,
      602526.,  502158.,  549534.,  598062.,  647742.,  401268.,  434388.,
      468276.,  502932.,  343860.,  378516.,  413940.,  450132.,  617070.,
      671358.,  726798.,  783390.,  655374.,  711966.,  769710.,  828606.,
      693678.,  752574.,  812622.,  873822.,  731982.,  793182.,  855534.,
      919038.,  572916.,  615252.,  658356.,  702228.,  478644.,  522516.,
      567156.,  612564.,  846894.,  915006.,  984270.,  1054686., 885198.,
      955614.,  1027182., 1099902., 923502.,  996222.,  1070094., 1145118.,
      961806.,  1036830., 1113006., 1190334., 744564.,  796116.,  848436.,
      901524.,  564664.,  598520.,  632888.,  667768.,  946772.,  999092.,
      1052180., 1106036., 981524.,  1035380., 1090004., 1145396., 1016276.,
      1071668., 1127828., 1184756., 1051028., 1107956., 1165652., 1224116.,
      778808.,  817784.,  857272.,  897272.,  330808.,  373880.,  417464.,
      461560.,  623636.,  689780.,  756692.,  824372.,  639956.,  707636.,
      776084.,  845300.,  656276.,  725492.,  795476.,  866228.,  672596.,
      743348.,  814868.,  887156.,  544952.,  593144.,  641848.,  691064.,
      882996.,  954516.,  1026804., 1099860., 1536366., 1645950., 1756686.,
      1868574., 1574670., 1686558., 1799598., 1913790., 1612974., 1727166.,
      1842510., 1959006., 1651278., 1767774., 1885422., 2004222., 1259508.,
      1338708., 1418676., 1499412., 1017780., 1098516., 1180020., 1262292.,
      1766190., 1889598., 2014158., 2139870., 1804494., 1930206., 2057070.,
      2185086., 1842798., 1970814., 2099982., 2230302., 1881102., 2011422.,
      2142894., 2275518., 1431156., 1519572., 1608756., 1698708., 1152564.,
      1242516., 1333236., 1424724., 1996014., 2133246., 2271630., 2411166.,
      2034318., 2173854., 2314542., 2456382., 2072622., 2214462., 2357454.,
      2501598., 2110926., 2255070., 2400366., 2546814., 1602804., 1700436.,
      1798836., 1898004., 1287348., 1386516., 1486452., 1587156., 2225838.,
      2376894., 2529102., 2682462., 2264142., 2417502., 2572014., 2727678.,
      2302446., 2458110., 2614926., 2772894., 2340750., 2498718., 2657838.,
      2818110., 1774452., 1881300., 1988916., 2097300., 1324984., 1395704.,
      1466936., 1538680., 2197844., 2305460., 2413844., 2522996., 2232596.,
      2341748., 2451668., 2562356., 2267348., 2378036., 2489492., 2601716.,
      2302100., 2414324., 2527316., 2641076., 1686584., 1762424., 1838776.,
      1915640., 648760.,  728696.,  809144.,  890104.,  1211156., 1332596.,
      1454804., 1577780., 1227476., 1350452., 1474196., 1598708., 1243796.,
      1368308., 1493588., 1619636., 1260116., 1386164., 1512980., 1640564.,
      1010360., 1095416., 1180984., 1267064., 1691700., 1818516., 1946100.,
      2074452., 2915310., 3107838., 3301518., 3496350., 2953614., 3148446.,
      3344430., 3541566., 2991918., 3189054., 3387342., 3586782., 3030222.,
      3229662., 3430254., 3631998., 2289396., 2423892., 2559156., 2695188.,
      1826484., 1962516., 2099316., 2236884., 3145134., 3351486., 3558990.,
      3767646., 3183438., 3392094., 3601902., 3812862., 3221742., 3432702.,
      3644814., 3858078., 3260046., 3473310., 3687726., 3903294., 2461044.,
      2604756., 2749236., 2894484., 1961268., 2106516., 2252532., 2399316.,
      3374958., 3595134., 3816462., 4038942., 3413262., 3635742., 3859374.,
      4084158., 3451566., 3676350., 3902286., 4129374., 3489870., 3716958.,
      3945198., 4174590., 2632692., 2785620., 2939316., 3093780., 2096052.,
      2250516., 2405748., 2561748., 3604782., 3838782., 4073934., 4310238.,
      3643086., 3879390., 4116846., 4355454., 3681390., 3919998., 4159758.,
      4400670., 3719694., 3960606., 4202670., 4445886., 2804340., 2966484.,
      3129396., 3293076., 2085304., 2192888., 2300984., 2409592., 3448916.,
      3611828., 3775508., 3939956., 3483668., 3648116., 3813332., 3979316.,
      3518420., 3684404., 3851156., 4018676., 3553172., 3720692., 3888980.,
      4058036., 2594360., 2707064., 2820280., 2934008.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}
TYPED_TEST(InputBackpropWindow3Stride1, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30.,      174.,     446.,     846.,     380.,     1180.,    2236.,
      3548.,    2074.,    4042.,    6394.,    9130.,    5626.,    8362.,
      11482.,   14986.,   8508.,    10844.,   13436.,   16284.,   6974.,
      8398.,    9950.,    11630.,   1180.,    3260.,    5596.,    8188.,
      10168.,   15352.,   21048.,   27256.,   29012.,   38324.,   48404.,
      59252.,   45332.,   56180.,   67796.,   80180.,   46904.,   55160.,
      63928.,   73208.,   32476.,   37116.,   42012.,   47164.,   15738.,
      21546.,   27738.,   34314.,   53940.,   67092.,   81012.,   95700.,
      117678.,  139710.,  162894.,  187230.,  155982.,  180318.,  205806.,
      232446.,  139764.,  157524.,  176052.,  195348.,  88794.,   98442.,
      108474.,  118890.,  54522.,   63402.,   72666.,   82314.,   143796.,
      163092.,  183156.,  203988.,  270894.,  302142.,  334542.,  368094.,
      309198.,  342750.,  377454.,  413310.,  254196.,  278100.,  302772.,
      328212.,  152154.,  164874.,  177978.,  191466.,  90716.,   98428.,
      106396.,  114620.,  211768.,  228216.,  245176.,  262648.,  365204.,
      391412.,  418388.,  446132.,  399956.,  427700.,  456212.,  485492.,
      305848.,  325368.,  345400.,  365944.,  173212.,  183484.,  194012.,
      204796.,  76638.,   81390.,   86270.,   91278.,   172028.,  182044.,
      192316.,  202844.,  287194.,  302986.,  319162.,  335722.,  309178.,
      325738.,  342682.,  360010.,  229308.,  240860.,  252668.,  264732.,
      126590.,  132622.,  138782.,  145070.,  2590.,    6830.,    11198.,
      15694.,   21884.,   30876.,   40124.,   49628.,   58906.,   73162.,
      87802.,   102826.,  62458.,   77482.,   92890.,   108682.,  62780.,
      73308.,   84092.,   95132.,   42302.,   47822.,   53470.,   59246.,
      55452.,   65724.,   76252.,   87036.,   151480.,  173048.,  195128.,
      217720.,  290132.,  324020.,  358676.,  394100.,  306452.,  341876.,
      378068.,  415028.,  253752.,  278392.,  303544.,  329208.,  152284.,
      165116.,  178204.,  191548.,  170874.,  188970.,  207450.,  226314.,
      413364.,  451092.,  489588.,  528852.,  730542.,  789438.,  849486.,
      910686.,  768846.,  830046.,  892398.,  955902.,  597492.,  639828.,
      682932.,  726804.,  342234.,  364170.,  386490.,  409194.,  209658.,
      230826.,  252378.,  274314.,  503220.,  547092.,  591732.,  637140.,
      883758.,  951870.,  1021134., 1091550., 922062.,  992478.,  1064046.,
      1136766., 711924.,  760404.,  809652.,  859668.,  405594.,  430602.,
      455994.,  481770.,  243292.,  259196.,  275356.,  291772.,  549688.,
      582520.,  615864.,  649720.,  921236.,  972020.,  1023572., 1075892.,
      955988.,  1008308., 1061396., 1115252., 709304.,  745208.,  781624.,
      818552.,  391324.,  409788.,  428508.,  447484.,  177502.,  186350.,
      195326.,  204430.,  390140.,  408348.,  426812.,  445532.,  638938.,
      667018.,  695482.,  724330.,  660922.,  689770.,  719002.,  748618.,
      480188.,  499932.,  519932.,  540188.,  260222.,  270350.,  280606.,
      290990.,  5150.,    13486.,   21950.,   30542.,   43388.,   60572.,
      78012.,   95708.,   115738.,  142282.,  169210.,  196522.,  119290.,
      146602.,  174298.,  202378.,  117052.,  135772.,  154748.,  173980.,
      77630.,   87246.,   96990.,   106862.,  109724.,  128188.,  146908.,
      165884.,  292792.,  330744.,  369208.,  408184.,  551252.,  609716.,
      668948.,  728948.,  567572.,  627572.,  688340.,  749876.,  460600.,
      501624.,  543160.,  585208.,  272092.,  293116.,  314396.,  335932.,
      326010.,  356394.,  387162.,  418314.,  772788.,  835092.,  898164.,
      962004.,  1343406., 1439166., 1536078., 1634142., 1381710., 1479774.,
      1578990., 1679358., 1055220., 1122132., 1189812., 1258260., 595674.,
      629898.,  664506.,  699498.,  364794.,  398250.,  432090.,  466314.,
      862644.,  931092.,  1000308., 1070292., 1496622., 1601598., 1707726.,
      1815006., 1534926., 1642206., 1750638., 1860222., 1169652., 1242708.,
      1316532., 1391124., 659034.,  696330.,  734010.,  772074.,  395868.,
      419964.,  444316.,  468924.,  887608.,  936824.,  986552.,  1036792.,
      1477268., 1552628., 1628756., 1705652., 1512020., 1588916., 1666580.,
      1745012., 1112760., 1165048., 1217848., 1271160., 609436.,  636092.,
      663004.,  690172.,  278366.,  291310.,  304382.,  317582.,  608252.,
      634652.,  661308.,  688220.,  990682.,  1031050., 1071802., 1112938.,
      1012666., 1053802., 1095322., 1137226., 731068.,  759004.,  787196.,
      815644.,  393854.,  408078.,  422430.,  436910.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_input_backprop_test(exp_out, in_shape, multiplier, padding,
                                max_input_val);
}